Como estudante, testemunhei em primeira mão a frustração causada pelo sistema ineficiente de achados e perdidos da nossa universidade. O processo atual, que depende de e-mails individuais para cada item encontrado, muitas vezes leva a atrasos e perda de conexões entre os pertences perdidos e seus proprietários.

Movido pelo desejo de melhorar essa experiência para mim e para meus colegas estudantes, embarquei em um projeto para explorar o potencial do aprendizado profundo para revolucionar nosso sistema de achados e perdidos. Nesta postagem do blog, compartilharei minha jornada de avaliação de modelos pré-treinados - ResNet, EfficientNet, VGG e NasNet - para automatizar a identificação e categorização de itens perdidos.

Através de uma análise comparativa, pretendo identificar o modelo mais adequado para integração em nosso sistema, criando, em última análise, uma experiência de achados e perdidos mais rápida, precisa e fácil de usar para todos no campus.

ResNet

Inception-ResNet V2 é uma poderosa arquitetura de rede neural convolucional disponível em Keras, combinando os pontos fortes da arquitetura Inception com conexões residuais do ResNet. Este modelo híbrido visa alcançar alta precisão em tarefas de classificação de imagens, mantendo a eficiência computacional.

Conjunto de dados de treinamento: ImageNet
Formato de imagem: 299 x 299

Função de pré-processamento

def readyForResNet(fileName):
    pic = load_img(fileName, target_size=(299, 299))
    pic_array = img_to_array(pic)
    expanded = np.expand_dims(pic_array, axis=0)
    return preprocess_input_resnet(expanded)

Previsão

data1 = readyForResNet(test_file)
prediction = inception_model_resnet.predict(data1)
res1 = decode_predictions_resnet(prediction, top=2)

VGG (Grupo de Geometria Visual)

VGG (Visual Geometry Group) é uma família de arquiteturas de redes neurais convolucionais profundas conhecidas por sua simplicidade e eficácia em tarefas de classificação de imagens. Esses modelos, especialmente VGG16 e VGG19, ganharam popularidade devido ao seu forte desempenho no ImageNet Large Scale Visual Recognition Challenge (ILSVRC) em 2014.

Conjunto de dados de treinamento: ImageNet
Formato de imagem: 224 x 224

Função de pré-processamento

def readyForVGG(fileName):
    pic = load_img(fileName, target_size=(224, 224))
    pic_array = img_to_array(pic)
    expanded = np.expand_dims(pic_array, axis=0)
    return preprocess_input_vgg19(expanded)

Previsão

data2 = readyForVGG(test_file)
prediction = inception_model_vgg19.predict(data2)
res2 = decode_predictions_vgg19(prediction, top=2)

EficienteNet

EfficientNet é uma família de arquiteturas de redes neurais convolucionais que alcançam precisão de última geração em tarefas de classificação de imagens, ao mesmo tempo que são significativamente menores e mais rápidas do que os modelos anteriores. Essa eficiência é alcançada por meio de um novo método de escalonamento composto que equilibra profundidade, largura e resolução da rede.

Conjunto de dados de treinamento: ImageNet
Formato de imagem: 480 x 480

Função de pré-processamento

def readyForEF(fileName):
    pic = load_img(fileName, target_size=(480, 480))
    pic_array = img_to_array(pic)
    expanded = np.expand_dims(pic_array, axis=0)
    return preprocess_input_EF(expanded)

Previsão

data3 = readyForEF(test_file)
prediction = inception_model_EF.predict(data3)
res3 = decode_predictions_EF(prediction, top=2)

NasNet

NasNet (Rede de Pesquisa de Arquitetura Neural) representa uma abordagem inovadora em aprendizado profundo, onde a arquitetura da própria rede neural é descoberta por meio de um processo de pesquisa automatizado. Este processo de busca visa encontrar a combinação ideal de camadas e conexões para alcançar alto desempenho em uma determinada tarefa.

Conjunto de dados de treinamento: ImageNet
Formato de imagem: 224 x 224

Função de pré-processamento

def readyForNN(fileName):
    pic = load_img(fileName, target_size=(224, 224))
    pic_array = img_to_array(pic)
    expanded = np.expand_dims(pic_array, axis=0)
    return preprocess_input_NN(expanded)

Previsão

data4 = readyForNN(test_file)
prediction = inception_model_NN.predict(data4)
res4 = decode_predictions_NN(prediction, top=2)

Confronto

Precisão

A tabela resume as pontuações de precisão reivindicadas dos modelos acima. EfficientNet B7 lidera com a maior precisão, seguido de perto por NasNet-Large e Inception-ResNet V2. Os modelos VGG apresentam precisões mais baixas. Para minha aplicação, quero escolher um modelo que tenha um equilíbrio entre tempo de processamento e precisão.

Tempo

Como podemos ver, EfficientNetB0 nos fornece os resultados mais rápidos, mas InceptionResNetV2 é um pacote melhor quando levada em consideração a precisão

Resumo

Para meu sistema inteligente de achados e perdidos, decidi usar o InceptionResNetV2. Embora o EfficientNet B7 parecesse tentador com sua precisão de alto nível, fiquei preocupado com suas demandas computacionais. Num ambiente universitário, onde os recursos podem ser limitados e o desempenho em tempo real é muitas vezes desejável, senti que era importante encontrar um equilíbrio entre precisão e eficiência. InceptionResNetV2 parecia ser o ajuste perfeito - oferece forte desempenho sem ser excessivamente intensivo em termos computacionais.

Além disso, o fato de ser pré-treinado no ImageNet me dá confiança de que ele pode lidar com a grande variedade de objetos que as pessoas podem perder. E não esqueçamos como é fácil trabalhar no Keras! Isso definitivamente tornou minha decisão mais fácil.

No geral, acredito que InceptionResNetV2 fornece a combinação certa de precisão, eficiência e praticidade para meu projeto. Estou animado para ver como ele funciona ajudando a reunir itens perdidos com seus proprietários!