Rede neural convolucional sob o capô

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


[Esteartigofoipublicadopelaprimeiravezem[Thisarticlewasfirstpublishedon R – Olá! Eu sou Nagdev, e gentilmente contribuiu para os R-blogueiros]. (Você pode relatar um problema sobre o conteúdo desta página aqui)


Deseja compartilhar seu conteúdo com R-blogueiros? clique aqui se você tiver um blog ou aqui se não tiver.

As redes neurais realmente assumiram o controle da resolução de problemas de reconhecimento de imagem e dados de alta taxa de amostragem nos últimos dois anos. Com toda a honestidade, prometo não ensinar a você o que são redes neurais ou CNN. Existem centenas de recursos que são publicados todos os dias, explicando-os. Vou postar alguns links abaixo.

Sou um usuário sério de R e muito novo no domínio Deep learning. Quando comecei a encontrar novos projetos de classificação de imagens, comecei a me inclinar para a CNN. Analisei alguns tutoriais sobre classificação de imagens usando a CNN e li alguns livros. Depois de alguns, comecei a ver o mesmo padrão antigo em todas as postagens do blog

  1. Baixar conjunto de dados
  2. Divida-os de três maneiras (trem / teste / validação)
  3. Crie um modelo (na maioria dos casos, modelos pré-treinados)
  4. Configurar geradores
  5. Compilar o modelo
  6. Prever
  7. Fim

Eu entendi o conceito de filtro, tamanho do filtro e funções de ativação. Mas eu estava curioso sobre o que a rede estava realmente vendo através do filtro. Pesquisei bastante e encontrei uma postagem sobre o stackoverflow com um link para o Keras-FAQ do RStudio. Foram literalmente três linhas de código para visualizar o que estava acontecendo em cada camada. Enquanto isso, em python, eram mais de duas dezenas de linhas de código. (Ironia!) Eu pensei que poderia haver algumas pessoas por aí que seriam interessantes em saber isso em R, assim como eu. Então, eu decidi escrever este post no blog. Seria muito útil quando você está explicando isso ao seu chefe ou a um colega de trabalho.

Vamos começar!

Configuração inicial

Fazendo Download do Conjunto de Dados

Neste exemplo, usarei o conjunto de dados de cães e gatos do Kaggle. Você pode seguir o link e baixar os dados. Pode ser necessário criar uma conta para fazer o download.

Se você possui seus próprios dados, não se preocupe com esta etapa. Pule isso.

Carregar biblioteca Keras

library(keras)

Divida os dados em trem e teste

O código abaixo é cortesia do blog Rstudio.

original_dataset_dir = "/home/rstudio/train"

base_dir = "/home/rstudio/data"
dir.create(base_dir)

train_dir = file.path(base_dir, "train")
dir.create(train_dir)

test_dir = file.path(base_dir, "test")
dir.create(test_dir)

train_cats_dir = file.path(train_dir, "cats")
dir.create(train_cats_dir)

train_dogs_dir = file.path(train_dir, "dogs")
dir.create(train_dogs_dir)

test_cats_dir = file.path(test_dir, "cats")
dir.create(test_cats_dir)

test_dogs_dir = file.path(test_dir, "dogs")
dir.create(test_dogs_dir)

fnames = paste0("cat.", 1:2000, ".jpg")
file.copy(file.path(original_dataset_dir, fnames), 
          file.path(train_cats_dir)) 

fnames = paste0("cat.", 2001:3000, ".jpg")
file.copy(file.path(original_dataset_dir, fnames),
          file.path(test_cats_dir)) fnames = paste0("dog.", 1:2000, ".jpg")
file.copy(file.path(original_dataset_dir, fnames),
          file.path(train_dogs_dir)) fnames = paste0("dog.", 2001:3000, ".jpg")
file.copy(file.path(original_dataset_dir, fnames),
          file.path(test_dogs_dir))

Definir parâmetros iniciais

Estou criando algumas variáveis ​​e atribuindo-lhes valores aqui. O principal motivo é que é fácil ajustá-los e treinar novamente os modelos.

# set path
path = "/home/rstudio/data/"

# set inital parameters
img_width = 150
img_height = 150
channels = 3
output_n = 2
train_samples = length(list.files(paste0(path,"train/cats"))) + length(list.files(paste0(path,"train/dogs")))
test_samples = length(list.files(paste0(path,"test/cats"))) + length(list.files(paste0(path,"test/dogs")))
batch_size = 50

# set dataset directory
train_dir = paste0(path,"train")
test_dir = paste0(path,"test")

Crie um modo personalizado

Eu poderia usar um modelo pré-treinado como VGG16 ou VGG18. Mas qual é a graça nisso? Deixe-me construir o meu. Não me julgue por más camadas. Eu ainda estou aprendendo.

# CNN model
  model = keras_model_sequential() %>% 
  layer_conv_2d(filters = 8, kernel_size = c(3,3), activation = "relu", input_shape = c(img_width,img_height,channels)) %>% 
  layer_conv_2d(filters = 16, kernel_size = c(3,3), activation = "relu") %>% 
  layer_max_pooling_2d(pool_size = c(2,2)) %>% 
  layer_conv_2d(filters = 32, kernel_size = c(3,3), activation = "relu") %>% 
  layer_max_pooling_2d(pool_size = c(2,2)) %>% 
  layer_conv_2d(filters = 64, kernel_size = c(3,3), activation = "relu") %>% 
  layer_max_pooling_2d(pool_size = c(2,2)) %>% 
  layer_conv_2d(filters = 16, kernel_size = c(3,3), activation = "relu") %>% 
  layer_flatten() %>% 
  layer_dense(units = 64, activation = "relu") %>% 
  layer_dense(units = 64, activation = "relu") %>% 
  layer_dropout(rate = 0.3) %>% 
  layer_dense(units = 128, activation = "relu") %>% 
  layer_dense(units = 128, activation = "relu") %>% 
  layer_dropout(rate = 0.3) %>% 
  layer_dense(units = 256, activation = "relu") %>% 
  layer_dense(units = 256, activation = "relu") %>% 
  layer_dropout(rate = 0.3) %>% 
  layer_dense(units = 64, activation = "relu") %>% 
  layer_dense(units = 64, activation = "relu") %>% 
  layer_dropout(rate = 0.3) %>% 
  layer_dense(units = 32, activation = "relu") %>% 
  layer_dense(units = output_n, activation = "softmax")

# summary of the overall model
summary(model)

Processamento de imagem

Configuração de aumento de imagem

Quando seu conjunto de dados é pequeno, o aumento ajuda a aumentar seu próprio conjunto de dados. Aqui temos alguns parâmetros, como rotação, deslocamento e zoom, que seriam adicionados ao seu conjunto de trens atual para aumentar o tamanho do trem.

# Train data image preprocessing
datagen = image_data_generator(
                               rotation_range = 40,
                               width_shift_range = 0.2,
                               height_shift_range = 0.2,
                               shear_range = 0.2,
                               zoom_range = 0.2,
                               horizontal_flip = TRUE,
                               fill_mode = "nearest",
                               samplewise_std_normalization = TRUE
                              )
# get all the train set
train_generator = flow_images_from_directory(
                                              train_dir,                 
                                              datagen,  
                                              color_mode = "rgb",
                                              target_size = c(img_width, img_height), 
                                              batch_size = batch_size,
                                              class_mode = "categorical", 
                                              shuffle = TRUE
)

# Get test data set
test_generator = flow_images_from_directory(
                                            test_dir,
                                            datagen,
                                            color_mode = "rgb",
                                            target_size =  c(img_width, img_height),
                                            batch_size = batch_size,
                                            class_mode = "categorical",
                                            shuffle = TRUE
)

Compilar e ajustar o modelo

Agora, que temos um modelo e geradores, podemos compilar o modelo e ajustar o gerador. Eu executei o modelo em 100 épocas algumas vezes e atingi uma precisão média de 80%. Nada mal para este modelo de teste!

# compile the model
model %>% compile(
                  loss = "binary_crossentropy",
                  optimizer = optimizer_adamax(lr = 0.001, decay = ),
                  metrics = c("accuracy")
)
history = model %>% fit_generator(
                                  train_generator,
                                  steps_per_epoch = as.integer(train_samples/batch_size),
                                  epochs = 100,
                                  validation_data = test_generator,
                                  validation_steps = 10,
                                  initial_epoch = 1
)

analisar 1

Visualizando uma Imagem de Teste Através de Camadas

Agora que temos um modelo, podemos escolher uma imagem de teste e passar por diferentes camadas que temos e visualizar o que acontece com a nossa imagem em cada camada. Isso nos dirá qual foi o ponto no objeto em que nossa rede está aprendendo. Abaixo, escolhemos uma imagem de teste que queremos testar nosso modelo.

# load image
x = image_load(paste0(path,"test/cats/cat.2001.jpg"),target_size =  c(img_width, img_height)) 
data = x %>% array_reshape(c(-1,img_width, img_height, channels))

image = jpeg::readJPEG(paste0(path,"test/cats/cat.2511.jpg"))
cat.2001
Em seguida, capturaremos uma camada intermediária, salvaremos a camada como modelo, preveremos nossa imagem com base no intermediário posteriormente. Obteremos uma saída de matriz multidimensional. Nos resultados abaixo, temos um tamanho de imagem de 33 x 33 e 64 filtros. Você pode ajustá-los para traçar os resultados.
Nota: Índice é o número da camada que queremos ver.
# what layer do we want to look at?
index = 6

# choose that layer as model
intermediate_layer_model = keras_model(inputs = model$input,
                                        outputs = get_layer(model, index = index)$output)

# predict on that layer
intermediate_output = predict(intermediate_layer_model, data)

# dimensionso of prediction
dim(intermediate_output)
[1]  1 33 33 64
Finalmente, podemos plotar nossos dados de matriz de cada um de nossos filtros em uma grade usando a função de imagem, como mostrado abaixo.
Nota: as imagens abaixo são giradas. Você pode girar as imagens usando a função de rotação da matriz.
par(mfrow = c(3,3))
for(i in 1:9){
  image(intermediate_output[1,,,i])
}

Camada 2

2

Camada 3

3

Camada 6

6

Conclusão

Do exposto acima, você pode ver como os filtros CNN estão estreitando o ponto de interesse do gato. Isso não apenas ajuda a explicar como o modelo está funcionando, mas também é uma maneira de confirmar se o modelo está funcionando como pretendido. Foi uma jornada e tanto percorrer as redes internas para encontrar uma maneira de visualizar minhas camadas. Espero que vocês possam usar isso para seus projetos.

Leia Também  desafio # explicarCovid19 | R-bloggers

Links para tutoriais

  1. Brincadeira de ShirinRound
  2. Rstudio Blog
  3. Rstudio Tensorflow
  4. R-Bloggers

var vglnk = {key: ‘949efb41171ac6ec1bf7f206d57e90b8’};

(função (d, t) {
var s = d.createElement
s.src = ‘//cdn.viglink.com/api/vglnk.js’;
var r = d.getElementsByTagName
} (documento, ‘script’));

Para Deixe um comentário para o autor, siga o link e comente no blog: R – Olá! Eu sou Nagdev.

R-bloggers.com oferece atualizações diárias por email sobre notícias e tutoriais do R sobre o aprendizado do R e muitos outros tópicos. Clique aqui se você deseja publicar ou encontrar um emprego em ciência da dados / R.


Deseja compartilhar seu conteúdo com R-blogueiros? clique aqui se você tiver um blog ou aqui se não tiver.



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