De quem é esse sonho? Quando e como usar a API funcional Keras

cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br


No entanto, em meus posts de blog, sempre usei Modelos sequenciais Keras e nunca mostrou como usar o API funcional. O motivo é que a API Funcional geralmente é aplicada na construção de modelos mais complexos, como modelos de múltiplas entradas ou saídas. E em meus posts de blog geralmente mostro exemplos simples que não levam muito tempo e capacidade de computação para serem executados, para que todos possam acompanhar.

Mas o API funcional também pode ser usado para construir modelos simples (na verdade, cada modelo construído com a API sequencial também pode ser construído com a API Funcional, mas não o contrário) Além disso, o API funcional pode ser usado para construir modelos complexos com múltiplas entradas e / ou múltiplas saídas. Então, vamos ver como isso funciona! 🙂

A propósito, pontos de brownie para aqueles que entendem a referência no meu título. 😉

Anúncio da oficina: Como o UseR 2020 deste ano em Munique não poderia acontecer como um evento presencial, vou dar meu workshop sobre Deep Learning com Keras e TensorFlow como um evento online na quinta-feira, 8 de outubro (13:00 UTC).

Se você tiver dúvidas ou quiser falar sobre este artigo (ou algo relacionado a dados), agora você pode reservar timeslots de 15 minutos comigo (é grátis – um slot disponível por dia da semana):

Se você tem gostado do meu conteúdo e gostaria de me ajudar a criar mais, por favor, considere me enviar uma doação para . Obrigado! 🙂

Tenho tido um problema com blogdown, onde o código abaixo é executado perfeitamente no meu console R a partir do arquivo RMarkdown, mas sempre que incluo qualquer função do keras pacote, blogdown::serve_site() lança um erro: Error in render_page(f) : Failed to render 'content/post/keras.Rmd'.

Já que não tenho ideia do que está acontecendo lá (blogdown::serve_site() constrói meu site sem problemas, desde que eu não inclua keras funções) e não obtive uma resposta para o problema que postei no Github, tive que escrever esta postagem do blog sem realmente executar o código enquanto construí o site.

Eu contornei esse problema não avaliando a maior parte do código abaixo e, em vez disso, executei o código localmente em meu computador. Objetos e imagens, salvei como .RData ou .png arquivos e coloque-os manualmente de volta no documento. Apenas lendo esta postagem do blog conforme ela foi renderizada em meu site, você não notará muita diferença (exceto onde copiei / colei a saída como comentários abaixo do código), mas para ser totalmente transparente, você pode ver no Github o que Eu fiz com pedaços de código ocultos para criar este post.

Carregando bibliotecas

# load libraries
library(tidyverse)
library(tidymodels)
library(tensorflow)
library(keras)
library(deepviz) # https://github.com/andrie/deepviz
tf$random$set_seed(42)

# check TF version
tf_version()
#[1] ‘2.2’

# check if keras is available
is_keras_available()
#[1] TRUE

Modelos sequenciais

Para muitos modelos, keras_model_sequential é suficiente! Sempre que seu modelo tiver uma entrada (ou seja, um conjunto de imagens, uma matriz, um conjunto de textos, etc.), uma camada de saída e uma ordem linear de camadas intermediárias, você pode usar o keras_model_sequential() função. Por exemplo, pode ser usado para construir MLPs, CNNs e LSTMs (bidirecionais) simples.

Você pode encontrar um exemplo completo de trabalho aqui.

Modelos complexos

Então, quando você usaria o API funcional? Você não pode usar o keras_model_sequential quando você deseja construir um modelo mais complexo, por exemplo, no caso de você ter vários (tipos de) entradas (como matriz, imagens e texto) ou várias saídas, ou mesmo conexões complexas entre camadas que não podem ser descritas de forma linear ( como gráficos acíclicos direcionados, por exemplo, em módulos de iniciação ou blocos residuais). Os exemplos incluem uma Rede Adversarial Gerativa de Classificador Auxiliar (ACGAN) e transferência de estilo neural.

Como usar a API Funcional

A principal função para usar o API funcional é chamado keras_model(). Com keras_model, você combina camadas de entrada e saída. Para facilitar o entendimento, vejamos um exemplo simples. Abaixo, estarei construindo o mesmo modelo da postagem do blog da semana passada, onde treinei um modelo de classificação de imagem com keras_model_sequential. Só que agora, vou usar o API funcional em vez de.

A primeira parte é idêntica à anterior: definir o gerador de dados da imagem a ser lido nas imagens de treinamento.

# path to image folders
train_image_files_path 
# list of fruits to model
fruit_list 
train_data_gen 
# training images
train_image_array_gen 
# number of training samples
train_samples 

Aqui está o que é diferente com o API funcional:

Com keras_model_sequential, começamos com essa função e adicionamos camadas uma após a outra até chegarmos à camada de saída. A primeira camada depois keras_model_sequential() precisa ter parâmetros de entrada que correspondam às dimensões dos dados de entrada (ou você começa com layer_input() como primeira camada). Este modelo completo é então compilado e ajustado.

Com o API funcional, começamos definindo a entrada com layer_input como um objeto separado. Pelo menos um outro objeto é definido contendo camadas adicionais e a camada de saída. Com keras_model(), combinamos a entrada e a saída em um modelo que é compilado e se ajusta da mesma forma que um modelo sequencial.

# input layer
inputs %
  layer_conv_2d(filter = 32, kernel_size = c(3,3), padding = "same") %>%
  layer_activation("relu") %>%
  
  # Second hidden layer
  layer_conv_2d(filter = 16, kernel_size = c(3,3), padding = "same") %>%
  layer_activation_leaky_relu(0.5) %>%
  layer_batch_normalization() %>%

  # Use max pooling
  layer_max_pooling_2d(pool_size = c(2,2)) %>%
  layer_dropout(0.25) %>%
  
  # Flatten max filtered output into feature vector 
  # and feed into dense layer
  layer_flatten() %>%
  layer_dense(100) %>%
  layer_activation("relu") %>%
  layer_dropout(0.5) %>%
  
  # Outputs from dense layer are projected onto output layer
  layer_dense(output_n) %>% 
  layer_activation("softmax")

# create and compile model
model_func % compile(
  loss = "categorical_crossentropy",
  optimizer = optimizer_rmsprop(lr = 0.0001, decay = 1e-6),
  metrics = "accuracy"
)

Este modelo aqui é muito simples e poderia ter sido construído facilmente com keras_model_sequential. Uma boa maneira de visualizar nossa arquitetura de modelo (particularmente, quando estamos construindo modelos complexos), é usar uma função de plotagem (aqui de deepviz):

model_func %>% plot_model()

# fit
model %>% fit_generator(
  # training data
  train_image_array_gen,
  
  # epochs
  steps_per_epoch = as.integer(train_samples / batch_size), 
  epochs = epochs, 
  
  # validation data
  validation_data = valid_image_array_gen,
  validation_steps = as.integer(valid_samples / batch_size)
)
Epoch 1/10
168/168 [==============================] - 9s 55ms/step - loss: 1.9132 - accuracy: 0.3986 - val_loss: 2.1233 - val_accuracy: 0.6797
Epoch 2/10
168/168 [==============================] - 6s 36ms/step - loss: 0.8035 - accuracy: 0.7469 - val_loss: 0.9889 - val_accuracy: 0.9362
Epoch 3/10
168/168 [==============================] - 6s 35ms/step - loss: 0.4647 - accuracy: 0.8560 - val_loss: 0.2568 - val_accuracy: 0.9648
Epoch 4/10
168/168 [==============================] - 6s 34ms/step - loss: 0.2953 - accuracy: 0.9126 - val_loss: 0.1357 - val_accuracy: 0.9705
Epoch 5/10
168/168 [==============================] - 6s 35ms/step - loss: 0.2089 - accuracy: 0.9428 - val_loss: 0.0888 - val_accuracy: 0.9692
Epoch 6/10
168/168 [==============================] - 6s 35ms/step - loss: 0.1505 - accuracy: 0.9568 - val_loss: 0.1001 - val_accuracy: 0.9774
Epoch 7/10
168/168 [==============================] - 6s 35ms/step - loss: 0.1135 - accuracy: 0.9689 - val_loss: 0.0793 - val_accuracy: 0.9805
Epoch 8/10
168/168 [==============================] - 6s 34ms/step - loss: 0.0957 - accuracy: 0.9734 - val_loss: 0.0628 - val_accuracy: 0.9818
Epoch 9/10
168/168 [==============================] - 6s 35ms/step - loss: 0.0733 - accuracy: 0.9797 - val_loss: 0.0525 - val_accuracy: 0.9831
Epoch 10/10
168/168 [==============================] - 6s 34ms/step - loss: 0.0607 - accuracy: 0.9844 - val_loss: 0.0438 - val_accuracy: 0.9848

Módulo de iniciação

Então, agora que vimos como o API funcional funciona em geral, podemos dar uma olhada em alguns exemplos mais complexos. O primeiro é o módulo de iniciação. Não vou entrar em detalhes sobre o que são os módulos de iniciação e para que são úteis, mas você pode encontrar uma boa descrição aqui.

Leia Também  Lançamento do RSwitch 1.7.0

O que é interessante em termos de construção do modelo é que o módulo de iniciação consiste em (blocos de) camadas paralelas. A saída de um módulo de iniciação é então combinada novamente em um. No modelo abaixo, uma entrada (nossas imagens de cima) está sendo alimentada em um módulo de iniciação que consiste em três blocos paralelos. Esses blocos podem consistir em quaisquer camadas e combinações de camadas que desejarmos. As três saídas diferentes são então combinadas novamente usando layer_concatenate(). Podemos agora criar módulos de iniciação adicionais ou criar a camada de saída. O resto é como antes: crie o modelo com keras_model(), compilar e ajustar.

# input layer
inputs %
  layer_conv_2d(filters = 32, kernel_size = c(1, 1), padding='same', activation='relu') %>%
  layer_conv_2d(filters = 32, kernel_size = c(3, 3), padding='same', activation='relu')

tower_2 %
  layer_conv_2d(filters = 32, kernel_size = c(1, 1), padding='same', activation='relu') %>%
  layer_conv_2d(filters = 32, kernel_size = c(5, 5), padding='same', activation='relu')

tower_3 %
  layer_max_pooling_2d(pool_size = c(2, 2), strides = c(1, 1), padding = 'same') %>%
  layer_conv_2d(filters = 32, kernel_size = c(1, 1), padding='same', activation='relu')

output %

  # Flatten max filtered output into feature vector 
  # and feed into dense layer
  layer_flatten() %>%
  layer_dense(100) %>%
  layer_activation("relu") %>%
  layer_dropout(0.5) %>%
  
  # Outputs from dense layer are projected onto output layer
  layer_dense(output_n) %>% 
  layer_activation("softmax")
# create and compile model
model_inc % compile(
  loss = "categorical_crossentropy",
  optimizer = optimizer_rmsprop(lr = 0.0001, decay = 1e-6),
  metrics = "accuracy"
)
model_inc %>% plot_model()

# fit
model_inc %>% fit_generator(
  # training data
  train_image_array_gen,
  
  # epochs
  steps_per_epoch = as.integer(train_samples / batch_size), 
  epochs = epochs, 
  
  # validation data
  validation_data = valid_image_array_gen,
  validation_steps = as.integer(valid_samples / batch_size)
)
Epoch 1/10
168/168 [==============================] - 16s 96ms/step - loss: 1.8178 - accuracy: 0.4377 - val_loss: 1.0520 - val_accuracy: 0.7630
Epoch 2/10
168/168 [==============================] - 17s 102ms/step - loss: 0.9190 - accuracy: 0.7283 - val_loss: 0.4448 - val_accuracy: 0.9271
Epoch 3/10
168/168 [==============================] - 16s 98ms/step - loss: 0.5711 - accuracy: 0.8374 - val_loss: 0.2429 - val_accuracy: 0.9531
Epoch 4/10
168/168 [==============================] - 17s 101ms/step - loss: 0.3920 - accuracy: 0.8931 - val_loss: 0.1571 - val_accuracy: 0.9644
Epoch 5/10
168/168 [==============================] - 19s 112ms/step - loss: 0.2787 - accuracy: 0.9201 - val_loss: 0.0967 - val_accuracy: 0.9657
Epoch 6/10
168/168 [==============================] - 17s 102ms/step - loss: 0.2191 - accuracy: 0.9398 - val_loss: 0.1057 - val_accuracy: 0.9653
Epoch 7/10
168/168 [==============================] - 16s 96ms/step - loss: 0.1828 - accuracy: 0.9438 - val_loss: 0.0658 - val_accuracy: 0.9922
Epoch 8/10
168/168 [==============================] - 16s 98ms/step - loss: 0.1463 - accuracy: 0.9590 - val_loss: 0.0536 - val_accuracy: 0.9852
Epoch 9/10
168/168 [==============================] - 17s 101ms/step - loss: 0.1266 - accuracy: 0.9616 - val_loss: 0.0520 - val_accuracy: 0.9913
Epoch 10/10
168/168 [==============================] - 16s 96ms/step - loss: 0.1040 - accuracy: 0.9687 - val_loss: 0.0526 - val_accuracy: 0.9822

Blocos residuais

Outra arquitetura de modelo útil usa blocos residuais (redes neurais residuais, particularmente ResNet). Os blocos residuais usam as chamadas conexões de salto. No meu exemplo abaixo, a entrada segue dois caminhos:

  1. Um bloco de convolução que se parece com o modelo sequencial.
  2. Uma conexão de salto que deixa de fora este bloco de convolução e alimenta a entrada diretamente para a próxima camada, que segue o bloco de convolução.

Basicamente, combinamos a entrada original de volta com a saída complicada da mesma entrada. Se quisermos combinar duas camadas com as mesmas dimensões, podemos usar layer_add().

# input layer
inputs %
  layer_conv_2d(filter = 32, kernel_size = c(3,3), padding = "same") %>%
  layer_activation("relu") %>%
  
  # Second hidden layer
  layer_conv_2d(filter = 3, kernel_size = c(3,3), padding = "same") %>%
  layer_activation("relu")

output %

  # Flatten max filtered output into feature vector 
  # and feed into dense layer
  layer_flatten() %>%
  layer_dense(100) %>%
  layer_activation("relu") %>%
  layer_dropout(0.5) %>%
  
  # Outputs from dense layer are projected onto output layer
  layer_dense(output_n) %>% 
  layer_activation("softmax")
# create and compile model
model_resid % compile(
  loss = "categorical_crossentropy",
  optimizer = optimizer_rmsprop(lr = 0.0001, decay = 1e-6),
  metrics = "accuracy"
)
model_resid %>% plot_model()

# fit
model_resid %>% fit_generator(
  # training data
  train_image_array_gen,
  
  # epochs
  steps_per_epoch = as.integer(train_samples / batch_size), 
  epochs = epochs, 
  
  # validation data
  validation_data = valid_image_array_gen,
  validation_steps = as.integer(valid_samples / batch_size)
)
Epoch 1/10
168/168 [==============================] - 9s 51ms/step - loss: 2.3554 - accuracy: 0.2714 - val_loss: 1.9230 - val_accuracy: 0.5703
Epoch 2/10
168/168 [==============================] - 5s 30ms/step - loss: 1.7206 - accuracy: 0.4677 - val_loss: 1.3296 - val_accuracy: 0.7530
Epoch 3/10
168/168 [==============================] - 5s 29ms/step - loss: 1.3213 - accuracy: 0.5981 - val_loss: 0.9415 - val_accuracy: 0.8555
Epoch 4/10
168/168 [==============================] - 5s 29ms/step - loss: 1.0495 - accuracy: 0.6854 - val_loss: 0.6883 - val_accuracy: 0.8689
Epoch 5/10
168/168 [==============================] - 5s 31ms/step - loss: 0.8421 - accuracy: 0.7372 - val_loss: 0.4917 - val_accuracy: 0.8750
Epoch 6/10
168/168 [==============================] - 5s 29ms/step - loss: 0.6806 - accuracy: 0.7974 - val_loss: 0.4055 - val_accuracy: 0.9123
Epoch 7/10
168/168 [==============================] - 5s 28ms/step - loss: 0.5870 - accuracy: 0.8178 - val_loss: 0.3217 - val_accuracy: 0.9379
Epoch 8/10
168/168 [==============================] - 5s 30ms/step - loss: 0.4839 - accuracy: 0.8532 - val_loss: 0.2688 - val_accuracy: 0.9410
Epoch 9/10
168/168 [==============================] - 5s 29ms/step - loss: 0.4278 - accuracy: 0.8735 - val_loss: 0.2196 - val_accuracy: 0.9661
Epoch 10/10
168/168 [==============================] - 5s 29ms/step - loss: 0.3656 - accuracy: 0.8868 - val_loss: 0.1770 - val_accuracy: 0.9657

Multi-saídas

Outro caso de uso comum para o API funcional está construindo modelos com várias entradas ou saídas. Aqui, vou mostrar um exemplo com uma entrada e várias saídas. Nota, o exemplo abaixo é definitivamente fabricado, mas eu só quero demonstrar como construir um modelo simples e pequeno. A maioria dos exemplos do mundo real é muito maior em termos de dados e recursos de computação necessários. Você pode encontrar alguns bons exemplos aqui e aqui (embora em Python, mas você descobrirá que o código de Keras e os nomes das funções são quase iguais aos de R).

Estou usando o conjunto de dados de avaliação do carro da UC Irvine:

car_data %
  remove_missing()

Variáveis ​​categóricas são convertidas em variáveis ​​fictícias com codificação one-hot (em um caso de uso real, eu provavelmente não faria isso, mas usaria embeddings ao invés).

library(caret)
dmy 

Só por curiosidade, estou dando uma olhada em como minhas variáveis ​​se correlacionam:

cormat %
  as_data_frame() %>%
  mutate(x = colnames(cormat)) %>%
  gather(key = "y", value = "value", doors2:safetymed)

cormat %>%
    remove_missing() %>%
    arrange(x, y) %>%
    ggplot(aes(x = x, y = y, fill = value)) + 
    geom_tile() +
    scale_fill_gradient2(low = "blue", high = "red", mid = "white", 
     midpoint = 0, limit = c(-1,1), space = "Lab", 
     name = "PearsonnCorrelation") +
    theme(axis.text.x = element_text(angle = 45, vjust = 1, hjust = 1)) 

Agora, estou preparando minhas duas saídas: quero que meu modelo preveja

  1. classe de carro (como classificação binária: inaceitável ou não)
  2. segurança do carro (como classificação de várias categorias: alta, média, baixa)
Y_log 
Y_class 

Agora, estou definindo minha arquitetura de modelo (não é de forma alguma otimizada, nem é uma arquitetura particularmente útil, mas sim usada para demonstrar algumas opções para usar e combinar camadas):

Leia Também  wrapr 2.0.0 up no CRAN
cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br
  • camada de entrada como antes
  • dois blocos paralelos: uma incorporação e uma camada densa
  • concatenando incorporação e saída densa
  • saída 1 (segurança): camada densa + softmax para crossentropy categórico
  • saída 2 (classe): sigmóide para crossentropy binário
# input layer
input_shape %
  
  layer_embedding(input_dim = input_shape, output_dim = 36) %>%
  layer_flatten()

# dense layer
dense10 %
  
  layer_dense(10) %>%
  layer_activation_leaky_relu() %>%
  layer_alpha_dropout(0.25)

# shared layer
shared %
  
  layer_dense(5) %>%
  layer_activation("relu") %>%
  layer_alpha_dropout(0.25) %>%
  
  layer_dense(units = output_n_safety, 
              activation = 'softmax', 
              name = 'output_safety')

# output class
output_n_class %
  
  layer_alpha_dropout(0.25) %>%

  layer_dense(units = output_n_class, 
              activation = 'sigmoid', # with binary_crossentropy
              name = 'output_class')

# create model & compile
model % 
  compile(
    loss = list(output_safety = "categorical_crossentropy",
                output_class = "binary_crossentropy"),
    optimizer = optimizer_adam(),
    metrics = "mse"
)
model %>% plot_model()

model %>% 
  fit(
    x = train_X,
    y = list(output_safety = train_Y_safety, 
             output_class = train_Y_class),
    validation_split = 0.2,
    epochs = 25,
    batch_size = 32
)
Epoch 1/25
44/44 [==============================] - 1s 21ms/step - loss: 2.0614 - output_safety_loss: 1.2896 - output_class_loss: 0.7718 - output_safety_mse: 0.2585 - output_class_mse: 0.2803 - val_loss: 1.7722 - val_output_safety_loss: 1.0987 - val_output_class_loss: 0.6735 - val_output_safety_mse: 0.2222 - val_output_class_mse: 0.2403
Epoch 2/25
44/44 [==============================] - 0s 6ms/step - loss: 1.9865 - output_safety_loss: 1.2517 - output_class_loss: 0.7347 - output_safety_mse: 0.2514 - output_class_mse: 0.2636 - val_loss: 1.7717 - val_output_safety_loss: 1.0988 - val_output_class_loss: 0.6729 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2404
Epoch 3/25
44/44 [==============================] - 0s 5ms/step - loss: 1.8930 - output_safety_loss: 1.2187 - output_class_loss: 0.6744 - output_safety_mse: 0.2452 - output_class_mse: 0.2385 - val_loss: 1.8024 - val_output_safety_loss: 1.0989 - val_output_class_loss: 0.7035 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2549
Epoch 4/25
44/44 [==============================] - 0s 5ms/step - loss: 1.8438 - output_safety_loss: 1.2163 - output_class_loss: 0.6275 - output_safety_mse: 0.2444 - output_class_mse: 0.2161 - val_loss: 1.8537 - val_output_safety_loss: 1.0990 - val_output_class_loss: 0.7548 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2758
Epoch 5/25
44/44 [==============================] - 0s 5ms/step - loss: 1.8193 - output_safety_loss: 1.2125 - output_class_loss: 0.6068 - output_safety_mse: 0.2450 - output_class_mse: 0.2073 - val_loss: 1.8755 - val_output_safety_loss: 1.0990 - val_output_class_loss: 0.7766 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2840
Epoch 6/25
44/44 [==============================] - 0s 5ms/step - loss: 1.7904 - output_safety_loss: 1.1899 - output_class_loss: 0.6006 - output_safety_mse: 0.2398 - output_class_mse: 0.2033 - val_loss: 1.8931 - val_output_safety_loss: 1.0991 - val_output_class_loss: 0.7941 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2902
Epoch 7/25
44/44 [==============================] - 0s 6ms/step - loss: 1.7696 - output_safety_loss: 1.1811 - output_class_loss: 0.5885 - output_safety_mse: 0.2372 - output_class_mse: 0.1989 - val_loss: 1.8554 - val_output_safety_loss: 1.0991 - val_output_class_loss: 0.7564 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2778
Epoch 8/25
44/44 [==============================] - 0s 5ms/step - loss: 1.7570 - output_safety_loss: 1.1919 - output_class_loss: 0.5652 - output_safety_mse: 0.2400 - output_class_mse: 0.1921 - val_loss: 1.8243 - val_output_safety_loss: 1.0992 - val_output_class_loss: 0.7251 - val_output_safety_mse: 0.2224 - val_output_class_mse: 0.2670
Epoch 9/25
44/44 [==============================] - 0s 5ms/step - loss: 1.7234 - output_safety_loss: 1.1578 - output_class_loss: 0.5655 - output_safety_mse: 0.2339 - output_class_mse: 0.1912 - val_loss: 1.8038 - val_output_safety_loss: 1.0992 - val_output_class_loss: 0.7046 - val_output_safety_mse: 0.2224 - val_output_class_mse: 0.2599
Epoch 10/25
44/44 [==============================] - 0s 5ms/step - loss: 1.7180 - output_safety_loss: 1.1670 - output_class_loss: 0.5509 - output_safety_mse: 0.2358 - output_class_mse: 0.1853 - val_loss: 1.7748 - val_output_safety_loss: 1.0993 - val_output_class_loss: 0.6755 - val_output_safety_mse: 0.2224 - val_output_class_mse: 0.2492
Epoch 11/25
44/44 [==============================] - 0s 5ms/step - loss: 1.6670 - output_safety_loss: 1.1498 - output_class_loss: 0.5173 - output_safety_mse: 0.2321 - output_class_mse: 0.1736 - val_loss: 1.7404 - val_output_safety_loss: 1.0992 - val_output_class_loss: 0.6412 - val_output_safety_mse: 0.2224 - val_output_class_mse: 0.2361
Epoch 12/25
44/44 [==============================] - 0s 5ms/step - loss: 1.6748 - output_safety_loss: 1.1461 - output_class_loss: 0.5287 - output_safety_mse: 0.2316 - output_class_mse: 0.1775 - val_loss: 1.7181 - val_output_safety_loss: 1.0992 - val_output_class_loss: 0.6189 - val_output_safety_mse: 0.2224 - val_output_class_mse: 0.2272
Epoch 13/25
44/44 [==============================] - 0s 5ms/step - loss: 1.6274 - output_safety_loss: 1.1239 - output_class_loss: 0.5035 - output_safety_mse: 0.2269 - output_class_mse: 0.1690 - val_loss: 1.6934 - val_output_safety_loss: 1.0991 - val_output_class_loss: 0.5943 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2168
Epoch 14/25
44/44 [==============================] - 0s 5ms/step - loss: 1.6217 - output_safety_loss: 1.1345 - output_class_loss: 0.4872 - output_safety_mse: 0.2290 - output_class_mse: 0.1635 - val_loss: 1.6746 - val_output_safety_loss: 1.0991 - val_output_class_loss: 0.5755 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2092
Epoch 15/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5843 - output_safety_loss: 1.1255 - output_class_loss: 0.4588 - output_safety_mse: 0.2280 - output_class_mse: 0.1523 - val_loss: 1.6546 - val_output_safety_loss: 1.0990 - val_output_class_loss: 0.5556 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.2011
Epoch 16/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5974 - output_safety_loss: 1.1255 - output_class_loss: 0.4720 - output_safety_mse: 0.2280 - output_class_mse: 0.1589 - val_loss: 1.6377 - val_output_safety_loss: 1.0990 - val_output_class_loss: 0.5386 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.1941
Epoch 17/25
44/44 [==============================] - 0s 6ms/step - loss: 1.5751 - output_safety_loss: 1.1243 - output_class_loss: 0.4508 - output_safety_mse: 0.2275 - output_class_mse: 0.1506 - val_loss: 1.6203 - val_output_safety_loss: 1.0990 - val_output_class_loss: 0.5213 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.1867
Epoch 18/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5572 - output_safety_loss: 1.1044 - output_class_loss: 0.4528 - output_safety_mse: 0.2233 - output_class_mse: 0.1515 - val_loss: 1.6252 - val_output_safety_loss: 1.0989 - val_output_class_loss: 0.5263 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.1891
Epoch 19/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5833 - output_safety_loss: 1.1199 - output_class_loss: 0.4634 - output_safety_mse: 0.2268 - output_class_mse: 0.1564 - val_loss: 1.6150 - val_output_safety_loss: 1.0988 - val_output_class_loss: 0.5162 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.1847
Epoch 20/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5536 - output_safety_loss: 1.1153 - output_class_loss: 0.4383 - output_safety_mse: 0.2256 - output_class_mse: 0.1476 - val_loss: 1.6119 - val_output_safety_loss: 1.0988 - val_output_class_loss: 0.5131 - val_output_safety_mse: 0.2223 - val_output_class_mse: 0.1832
Epoch 21/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5408 - output_safety_loss: 1.1114 - output_class_loss: 0.4294 - output_safety_mse: 0.2250 - output_class_mse: 0.1455 - val_loss: 1.6087 - val_output_safety_loss: 1.0987 - val_output_class_loss: 0.5100 - val_output_safety_mse: 0.2222 - val_output_class_mse: 0.1814
Epoch 22/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5481 - output_safety_loss: 1.1143 - output_class_loss: 0.4339 - output_safety_mse: 0.2256 - output_class_mse: 0.1452 - val_loss: 1.6057 - val_output_safety_loss: 1.0987 - val_output_class_loss: 0.5070 - val_output_safety_mse: 0.2222 - val_output_class_mse: 0.1796
Epoch 23/25
44/44 [==============================] - 0s 7ms/step - loss: 1.5457 - output_safety_loss: 1.1100 - output_class_loss: 0.4357 - output_safety_mse: 0.2247 - output_class_mse: 0.1474 - val_loss: 1.5967 - val_output_safety_loss: 1.0987 - val_output_class_loss: 0.4980 - val_output_safety_mse: 0.2222 - val_output_class_mse: 0.1745
Epoch 24/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5310 - output_safety_loss: 1.1046 - output_class_loss: 0.4264 - output_safety_mse: 0.2235 - output_class_mse: 0.1434 - val_loss: 1.6002 - val_output_safety_loss: 1.0987 - val_output_class_loss: 0.5016 - val_output_safety_mse: 0.2222 - val_output_class_mse: 0.1749
Epoch 25/25
44/44 [==============================] - 0s 5ms/step - loss: 1.5385 - output_safety_loss: 1.1073 - output_class_loss: 0.4312 - output_safety_mse: 0.2240 - output_class_mse: 0.1456 - val_loss: 1.6007 - val_output_safety_loss: 1.0987 - val_output_class_loss: 0.5020 - val_output_safety_mse: 0.2222 - val_output_class_mse: 0.1751

devtools::session_info()
## ─ Session info ───────────────────────────────────────────────────────────────
##  setting  value                       
##  version  R version 4.0.2 (2020-06-22)
##  os       macOS Catalina 10.15.6      
##  system   x86_64, darwin17.0          
##  ui       X11                         
##  language (EN)                        
##  collate  en_US.UTF-8                 
##  ctype    en_US.UTF-8                 
##  tz       Europe/Berlin               
##  date     2020-09-17                  
## 
## ─ Packages ───────────────────────────────────────────────────────────────────
##  package      * version      date       lib source                             
##  assertthat     0.2.1        2019-03-21 [1] CRAN (R 4.0.0)                     
##  backports      1.1.9        2020-08-24 [1] CRAN (R 4.0.2)                     
##  base64enc      0.1-3        2015-07-28 [1] CRAN (R 4.0.0)                     
##  blob           1.2.1        2020-01-20 [1] CRAN (R 4.0.2)                     
##  blogdown       0.20.1       2020-09-09 [1] Github (rstudio/[email protected])  
##  bookdown       0.20         2020-06-23 [1] CRAN (R 4.0.2)                     
##  broom        * 0.7.0        2020-07-09 [1] CRAN (R 4.0.2)                     
##  callr          3.4.4        2020-09-07 [1] CRAN (R 4.0.2)                     
##  caret        * 6.0-86       2020-03-20 [1] CRAN (R 4.0.0)                     
##  cellranger     1.1.0        2016-07-27 [1] CRAN (R 4.0.0)                     
##  class          7.3-17       2020-04-26 [1] CRAN (R 4.0.2)                     
##  cli            2.0.2        2020-02-28 [1] CRAN (R 4.0.0)                     
##  codetools      0.2-16       2018-12-24 [1] CRAN (R 4.0.2)                     
##  colorspace     1.4-1        2019-03-18 [1] CRAN (R 4.0.0)                     
##  crayon         1.3.4        2017-09-16 [1] CRAN (R 4.0.0)                     
##  data.table     1.13.0       2020-07-24 [1] CRAN (R 4.0.2)                     
##  DBI            1.1.0        2019-12-15 [1] CRAN (R 4.0.0)                     
##  dbplyr         1.4.4        2020-05-27 [1] CRAN (R 4.0.2)                     
##  deepviz      * 0.0.1.9000   2020-09-15 [1] Github (andrie/[email protected])    
##  desc           1.2.0        2018-05-01 [1] CRAN (R 4.0.0)                     
##  devtools       2.3.1        2020-07-21 [1] CRAN (R 4.0.2)                     
##  DiagrammeR     1.0.6.1      2020-05-08 [1] CRAN (R 4.0.2)                     
##  dials        * 0.0.8        2020-07-08 [1] CRAN (R 4.0.2)                     
##  DiceDesign     1.8-1        2019-07-31 [1] CRAN (R 4.0.2)                     
##  digest         0.6.25       2020-02-23 [1] CRAN (R 4.0.0)                     
##  dplyr        * 1.0.2        2020-08-18 [1] CRAN (R 4.0.2)                     
##  ellipsis       0.3.1        2020-05-15 [1] CRAN (R 4.0.0)                     
##  evaluate       0.14         2019-05-28 [1] CRAN (R 4.0.1)                     
##  fansi          0.4.1        2020-01-08 [1] CRAN (R 4.0.0)                     
##  farver         2.0.3        2020-01-16 [1] CRAN (R 4.0.0)                     
##  forcats      * 0.5.0        2020-03-01 [1] CRAN (R 4.0.0)                     
##  foreach        1.5.0        2020-03-30 [1] CRAN (R 4.0.0)                     
##  fs             1.5.0        2020-07-31 [1] CRAN (R 4.0.2)                     
##  furrr          0.1.0        2018-05-16 [1] CRAN (R 4.0.2)                     
##  future         1.18.0       2020-07-09 [1] CRAN (R 4.0.2)                     
##  generics       0.0.2        2018-11-29 [1] CRAN (R 4.0.0)                     
##  ggforce        0.3.2        2020-06-23 [1] CRAN (R 4.0.2)                     
##  ggplot2      * 3.3.2        2020-06-19 [1] CRAN (R 4.0.2)                     
##  ggraph         2.0.3        2020-05-20 [1] CRAN (R 4.0.2)                     
##  ggrepel        0.8.2        2020-03-08 [1] CRAN (R 4.0.2)                     
##  globals        0.12.5       2019-12-07 [1] CRAN (R 4.0.2)                     
##  glue           1.4.2        2020-08-27 [1] CRAN (R 4.0.2)                     
##  gower          0.2.2        2020-06-23 [1] CRAN (R 4.0.2)                     
##  GPfit          1.0-8        2019-02-08 [1] CRAN (R 4.0.2)                     
##  graphlayouts   0.7.0        2020-04-25 [1] CRAN (R 4.0.2)                     
##  gridExtra      2.3          2017-09-09 [1] CRAN (R 4.0.2)                     
##  gtable         0.3.0        2019-03-25 [1] CRAN (R 4.0.0)                     
##  haven          2.3.1        2020-06-01 [1] CRAN (R 4.0.2)                     
##  hms            0.5.3        2020-01-08 [1] CRAN (R 4.0.0)                     
##  htmltools      0.5.0        2020-06-16 [1] CRAN (R 4.0.2)                     
##  htmlwidgets    1.5.1        2019-10-08 [1] CRAN (R 4.0.0)                     
##  httr           1.4.2        2020-07-20 [1] CRAN (R 4.0.2)                     
##  igraph         1.2.5        2020-03-19 [1] CRAN (R 4.0.0)                     
##  infer        * 0.5.3        2020-07-14 [1] CRAN (R 4.0.2)                     
##  ipred          0.9-9        2019-04-28 [1] CRAN (R 4.0.0)                     
##  iterators      1.0.12       2019-07-26 [1] CRAN (R 4.0.0)                     
##  jsonlite       1.7.1        2020-09-07 [1] CRAN (R 4.0.2)                     
##  keras        * 2.3.0.0.9000 2020-09-15 [1] Github (rstudio/[email protected])     
##  knitr          1.29         2020-06-23 [1] CRAN (R 4.0.2)                     
##  labeling       0.3          2014-08-23 [1] CRAN (R 4.0.0)                     
##  lattice      * 0.20-41      2020-04-02 [1] CRAN (R 4.0.2)                     
##  lava           1.6.7        2020-03-05 [1] CRAN (R 4.0.0)                     
##  lhs            1.0.2        2020-04-13 [1] CRAN (R 4.0.2)                     
##  lifecycle      0.2.0        2020-03-06 [1] CRAN (R 4.0.0)                     
##  listenv        0.8.0        2019-12-05 [1] CRAN (R 4.0.2)                     
##  lubridate      1.7.9        2020-06-08 [1] CRAN (R 4.0.2)                     
##  magrittr       1.5          2014-11-22 [1] CRAN (R 4.0.0)                     
##  MASS           7.3-53       2020-09-09 [1] CRAN (R 4.0.2)                     
##  Matrix         1.2-18       2019-11-27 [1] CRAN (R 4.0.2)                     
##  memoise        1.1.0        2017-04-21 [1] CRAN (R 4.0.0)                     
##  modeldata    * 0.0.2        2020-06-22 [1] CRAN (R 4.0.2)                     
##  ModelMetrics   1.2.2.2      2020-03-17 [1] CRAN (R 4.0.0)                     
##  modelr         0.1.8        2020-05-19 [1] CRAN (R 4.0.2)                     
##  munsell        0.5.0        2018-06-12 [1] CRAN (R 4.0.0)                     
##  nlme           3.1-149      2020-08-23 [1] CRAN (R 4.0.2)                     
##  nnet           7.3-14       2020-04-26 [1] CRAN (R 4.0.2)                     
##  parsnip      * 0.1.3        2020-08-04 [1] CRAN (R 4.0.2)                     
##  pillar         1.4.6        2020-07-10 [1] CRAN (R 4.0.2)                     
##  pkgbuild       1.1.0        2020-07-13 [1] CRAN (R 4.0.2)                     
##  pkgconfig      2.0.3        2019-09-22 [1] CRAN (R 4.0.0)                     
##  pkgload        1.1.0        2020-05-29 [1] CRAN (R 4.0.2)                     
##  plyr           1.8.6        2020-03-03 [1] CRAN (R 4.0.0)                     
##  polyclip       1.10-0       2019-03-14 [1] CRAN (R 4.0.2)                     
##  prettyunits    1.1.1        2020-01-24 [1] CRAN (R 4.0.0)                     
##  pROC           1.16.2       2020-03-19 [1] CRAN (R 4.0.0)                     
##  processx       3.4.4        2020-09-03 [1] CRAN (R 4.0.2)                     
##  prodlim        2019.11.13   2019-11-17 [1] CRAN (R 4.0.0)                     
##  ps             1.3.4        2020-08-11 [1] CRAN (R 4.0.2)                     
##  purrr        * 0.3.4        2020-04-17 [1] CRAN (R 4.0.0)                     
##  R6             2.4.1        2019-11-12 [1] CRAN (R 4.0.0)                     
##  RColorBrewer   1.1-2        2014-12-07 [1] CRAN (R 4.0.0)                     
##  Rcpp           1.0.5        2020-07-06 [1] CRAN (R 4.0.2)                     
##  readr        * 1.3.1        2018-12-21 [1] CRAN (R 4.0.0)                     
##  readxl         1.3.1        2019-03-13 [1] CRAN (R 4.0.0)                     
##  recipes      * 0.1.13       2020-06-23 [1] CRAN (R 4.0.2)                     
##  remotes        2.2.0        2020-07-21 [1] CRAN (R 4.0.2)                     
##  reprex         0.3.0        2019-05-16 [1] CRAN (R 4.0.0)                     
##  reshape2       1.4.4        2020-04-09 [1] CRAN (R 4.0.0)                     
##  reticulate     1.16-9001    2020-09-15 [1] Github (rstudio/[email protected])
##  rlang          0.4.7        2020-07-09 [1] CRAN (R 4.0.2)                     
##  rmarkdown      2.3          2020-06-18 [1] CRAN (R 4.0.2)                     
##  rpart          4.1-15       2019-04-12 [1] CRAN (R 4.0.2)                     
##  rprojroot      1.3-2        2018-01-03 [1] CRAN (R 4.0.0)                     
##  rsample      * 0.0.7        2020-06-04 [1] CRAN (R 4.0.2)                     
##  rstudioapi     0.11         2020-02-07 [1] CRAN (R 4.0.0)                     
##  rvest          0.3.6        2020-07-25 [1] CRAN (R 4.0.2)                     
##  scales       * 1.1.1        2020-05-11 [1] CRAN (R 4.0.0)                     
##  sessioninfo    1.1.1        2018-11-05 [1] CRAN (R 4.0.0)                     
##  stringi        1.5.3        2020-09-09 [1] CRAN (R 4.0.2)                     
##  stringr      * 1.4.0        2019-02-10 [1] CRAN (R 4.0.0)                     
##  survival       3.2-3        2020-06-13 [1] CRAN (R 4.0.2)                     
##  tensorflow   * 2.2.0.9000   2020-09-15 [1] Github (rstudio/[email protected])
##  testthat       2.3.2        2020-03-02 [1] CRAN (R 4.0.0)                     
##  tfruns         1.4          2018-08-25 [1] CRAN (R 4.0.0)                     
##  tibble       * 3.0.3        2020-07-10 [1] CRAN (R 4.0.2)                     
##  tidygraph      1.2.0        2020-05-12 [1] CRAN (R 4.0.2)                     
##  tidymodels   * 0.1.1        2020-07-14 [1] CRAN (R 4.0.2)                     
##  tidyr        * 1.1.2        2020-08-27 [1] CRAN (R 4.0.2)                     
##  tidyselect     1.1.0        2020-05-11 [1] CRAN (R 4.0.0)                     
##  tidyverse    * 1.3.0        2019-11-21 [1] CRAN (R 4.0.0)                     
##  timeDate       3043.102     2018-02-21 [1] CRAN (R 4.0.0)                     
##  tune         * 0.1.1        2020-07-08 [1] CRAN (R 4.0.2)                     
##  tweenr         1.0.1        2018-12-14 [1] CRAN (R 4.0.2)                     
##  usethis        1.6.1        2020-04-29 [1] CRAN (R 4.0.0)                     
##  vctrs          0.3.4        2020-08-29 [1] CRAN (R 4.0.2)                     
##  viridis        0.5.1        2018-03-29 [1] CRAN (R 4.0.2)                     
##  viridisLite    0.3.0        2018-02-01 [1] CRAN (R 4.0.0)                     
##  visNetwork     2.0.9        2019-12-06 [1] CRAN (R 4.0.2)                     
##  whisker        0.4          2019-08-28 [1] CRAN (R 4.0.0)                     
##  withr          2.2.0        2020-04-20 [1] CRAN (R 4.0.0)                     
##  workflows    * 0.1.3        2020-08-10 [1] CRAN (R 4.0.2)                     
##  xfun           0.17         2020-09-09 [1] CRAN (R 4.0.2)                     
##  xml2           1.3.2        2020-04-23 [1] CRAN (R 4.0.0)                     
##  yaml           2.2.1        2020-02-01 [1] CRAN (R 4.0.0)                     
##  yardstick    * 0.0.7        2020-07-13 [1] CRAN (R 4.0.2)                     
##  zeallot        0.1.0        2018-01-28 [1] CRAN (R 4.0.0)                     
## 
## [1] /Library/Frameworks/R.framework/Versions/4.0/Resources/library
Leia Também  quantmod_0.4-16 no CRAN | R-bloggers



cupom com desconto - o melhor site de cupom de desconto cupomcomdesconto.com.br