Alai

Introdução

“Construir um modelo de aprendizagem profunda em poucos minutos? Vai levar horas para treinar! Eu nem sequer tenho uma máquina suficientemente boa”. Já ouvi isso inúmeras vezes de aspirantes a cientistas de dados que se esquivam de construir modelos de aprendizagem profunda em suas próprias máquinas.

Você não precisa estar trabalhando para o Google ou outras grandes empresas de tecnologia para trabalhar em conjuntos de dados de aprendizagem profunda! É inteiramente possível construir sua própria rede neural a partir do zero em questão de minutos sem precisar alugar os servidores do Google. Fast.ai’s students designed a model on the Imagenet dataet in 18 minutes – and I will showcase something similar in this article.

Deep learning is a vast field so we’ll narrow our focus a bit and take up the challenge of solving an Image Classification project. Adicionalmente, vamos utilizar uma arquitectura de aprendizagem profunda muito simples para alcançar uma pontuação de precisão bastante impressionante.

Você pode considerar o código Python que vamos ver neste artigo como uma referência para a construção de modelos de Classificação de Imagens. Uma vez que você tenha uma boa compreensão do conceito, vá em frente e brinque com o código, participe de competições e suba na tabela de classificação!

Se você é novo no aprendizado profundo e é fascinado pelo campo da visão computacional (quem não é?!), confira o curso ‘Computer Vision using Deep Learning’. É uma introdução abrangente a este campo maravilhoso e vai prepará-lo para o que inevitavelmente vai para um enorme mercado de trabalho num futuro próximo.

Projecto para aplicar a Classificação de Imagens

Mais de 25% de toda a receita no E-Commerce é atribuída ao vestuário & acessórios. Um grande problema que eles enfrentam é a categorização destes acessórios a partir apenas das imagens, especialmente quando as categorias fornecidas pelas marcas são inconsistentes. Isto coloca um interessante problema de visão computacional que chamou a atenção de vários pesquisadores de aprendizagem profunda.

Fashion MNIST é um substituto para o muito conhecido, olá de aprendizagem de máquinas – conjunto de dados MNIST que pode ser verificado em ‘Identifique os dígitos’ problema de prática. Ao invés de dígitos, as imagens mostram um tipo de vestuário, por exemplo, camiseta, calça, bolsa, etc. O conjunto de dados usado neste problema foi criado pela Zalando Research.

Practice Now

Tabela de Conteúdos

1. Qual é a Classificação da Imagem e seus casos de uso
2. Configurando a Estrutura dos Dados da nossa Imagem
3. Quebrando a Construção do Modelo Processo
4. Configurar a Declaração do Problema e Compreender os Dados
5. Passos para Construir o Modelo de Classificação de Imagens
6. Agurar Outro Desafio

>

O que é Classificação de Imagens?

Consulte a imagem abaixo:

Terá reconhecido instantaneamente – é um carro (elegante). Dê um passo atrás e analise como chegou a esta conclusão – foi-lhe mostrada uma imagem e você classificou a classe a que pertencia (um carro, neste caso). E isso, em resumo, é o que é a classificação da imagem.

Existem potencialmente n número de categorias nas quais uma determinada imagem pode ser classificada. A verificação e classificação manual de imagens é um processo muito tedioso. A tarefa torna-se quase impossível quando somos confrontados com um grande número de imagens, digamos 10.000 ou mesmo 100.000. Como seria útil se pudéssemos automatizar todo este processo e rotular rapidamente as imagens por sua classe correspondente?

A auto-condução é um grande exemplo para entender onde a classificação de imagens é usada no mundo real. Para permitir uma condução autónoma, podemos construir um modelo de classificação de imagens que reconheça vários objectos, tais como veículos, pessoas, objectos em movimento, etc., na estrada. Veremos mais alguns casos de uso mais tarde neste artigo, mas há muito mais aplicações à nossa volta. Use a seção de comentários abaixo do artigo para me informar quais os casos de uso potenciais que você pode ter!

Agora temos um controle sobre o nosso assunto, vamos mergulhar em como um modelo de classificação de imagens é construído, quais são os pré-requisitos para ele, e como ele pode ser implementado em Python.

Configurando a estrutura dos nossos dados de imagem

Nossos dados precisam estar em um formato particular, a fim de resolver um problema de classificação de imagens. Nós veremos isso em ação em algumas seções, mas apenas mantenha estes ponteiros em mente até chegarmos lá.

Você deve ter 2 pastas, uma para o conjunto de trem e outra para o conjunto de teste. No conjunto de treinamento, você terá um arquivo .csv e uma pasta de imagens:

• O arquivo .csv contém os nomes de todas as imagens de treinamento e suas etiquetas verdadeiras correspondentes
• A pasta de imagens tem todas as imagens de treinamento.

O arquivo .csv no nosso conjunto de teste é diferente daquele presente no conjunto de treinamento. Este arquivo .csv do conjunto de testes contém os nomes de todas as imagens de teste, mas elas não têm nenhuma etiqueta correspondente. Você pode adivinhar por quê? Nosso modelo será treinado nas imagens presentes no conjunto de treinamento e as previsões das etiquetas acontecerão nas imagens do conjunto de teste

Se seus dados não estiverem no formato descrito acima, você precisará convertê-los de acordo (caso contrário as previsões serão erradas e bastante inúteis).

Quebrando o Processo de Construção do Modelo

Antes de mergulharmos fundo no código Python, vamos tirar um momento para entender como um modelo de classificação de imagem é tipicamente projetado. Podemos dividir este processo amplamente em 4 etapas. Cada estágio requer um certo tempo para executar:

1. Carregamento e pré-processamento de dados – 30% tempo
2. Definindo a arquitetura do modelo – 10% tempo
3. Treinamento do modelo – 50% tempo
4. Estimativa de performance – 10% tempo

Deixe-me explicar cada um dos passos acima com um pouco mais de detalhe. Esta secção é crucial porque nem todos os modelos são construídos na primeira tentativa. Você precisará voltar após cada iteração, afinar seus passos e executá-lo novamente. Ter uma sólida compreensão dos conceitos subjacentes irá acelerar o processo inteiro.

Estágio 1: Carregando e pré-processando os dados

Os dados são ouro no que diz respeito a modelos de aprendizagem profunda. O seu modelo de classificação de imagens tem muito mais chances de ter um bom desempenho se você tiver uma boa quantidade de imagens no conjunto de treinamento. Além disso, a forma dos dados varia de acordo com a arquitetura/estrutura que usamos.

Hence, a etapa crítica do pré-processamento de dados (a etapa eternamente importante em qualquer projeto). Recomendo vivamente que passemos pelo ‘Basics of Image Processing in Python’ para entender mais sobre como o pré-processamento funciona com dados de imagem.

Mas ainda não estamos lá. Para ver como nosso modelo funciona com dados não vistos (e antes de expô-lo ao conjunto de teste), precisamos criar um conjunto de validação. Isto é feito através do particionamento dos dados do conjunto de treinamento.

Em resumo, treinamos o modelo nos dados de treinamento e o validamos nos dados de validação. Quando estivermos satisfeitos com o desempenho do modelo no conjunto de validação, podemos usá-lo para fazer previsões nos dados de teste.

Tempo necessário para este passo: Necessitamos de cerca de 2-3 minutos para esta tarefa.

Etapa 2: Definindo a arquitetura do modelo

Esta é outra etapa crucial no nosso processo de construção do modelo de aprendizagem profunda. Temos que definir como nosso modelo será e isso requer respostas a perguntas como:

• Quantas camadas convolucionais queremos?
• Qual deve ser a função de ativação para cada camada?
• Quantas unidades ocultas cada camada deve ter?

E muitas mais. Estes são essencialmente os hiperparâmetros do modelo que desempenham um papel MASSIVO na decisão de quão boas serão as previsões.

Como decidimos estes valores? Excelente pergunta! Uma boa idéia é escolher estes valores com base em pesquisas/estudos existentes. Outra idéia é continuar experimentando com os valores até encontrar a melhor combinação, mas este pode ser um processo bastante demorado.

Tempo necessário para este passo: Deve levar cerca de 1 minuto para definir a arquitetura do modelo.

Etapa 3: Treinando o modelo

Para treinar o modelo, nós precisamos:

• Formando imagens e seus correspondentes true labels
• Validação de imagens e seus correspondentes true labels (nós usamos estes labels somente para validar o modelo e não durante a fase de treinamento)

Nós também definimos o número de épocas nesta etapa. Para começar, vamos executar o modelo para 10 épocas (você pode alterar o número de épocas depois).

Tempo necessário para esta etapa: Como o treinamento requer o modelo para aprender estruturas, precisamos de cerca de 5 minutos para passar por este passo.

E agora é hora de fazer previsões!

Etapa 4: Estimando o desempenho do modelo

Finalmente, carregamos os dados do teste (imagens) e passamos pela etapa de pré-processamento também aqui. Prevemos então as classes para estas imagens usando o modelo treinado.

Tempo necessário para este passo: ~ 1 minuto.

Configurando a Declaração do Problema e Entendendo os Dados

Estaremos pegando um desafio muito legal para entender a classificação das imagens. Temos de construir um modelo que possa classificar um determinado conjunto de imagens de acordo com o vestuário (camisa, calças, sapatos, meias, etc.). Na verdade, é um problema enfrentado por muitos varejistas de comércio eletrônico, o que o torna um problema ainda mais interessante de visão do computador.

Este desafio se chama ‘Identifique as Aparências’ e é um dos problemas práticos que temos em nossa plataforma DataHack. Você terá que se registrar e baixar o conjunto de dados do link acima.

Temos um total de 70.000 imagens (28 x 28 dimensão), das quais 60.000 são do conjunto de treinamento e 10.000 do teste. As imagens de treinamento são pré-rotuladas de acordo com o tipo de vestuário, com 10 aulas no total. As imagens do teste não são, naturalmente, etiquetadas. O desafio é identificar o tipo de vestuário presente em todas as imagens de teste.

Fazeremos o nosso modelo no Google Colab, uma vez que ele fornece uma GPU gratuita para treinar os nossos modelos.

Passos para construir o nosso modelo

Tempo para disparar as suas habilidades Python e sujar as suas mãos. Estamos finalmente na parte da implementação do nosso aprendizado!

>

1. Configurando o Google Colab
2. Importando bibliotecas
3. Carregando e pré-processando dados – (3 mins)
4. Criando um conjunto de validação
5. Definir a estrutura do modelo – (1 min)
6. Treinar o modelo – (5 min)
7. Fazer previsões – (1 min)

Vejamos cada passo em detalhe.

Passo 1: Configurando o Google Colab

Posto que estamos importando nossos dados de um link do Google Drive, vamos precisar adicionar algumas linhas de código no nosso caderno do Google Colab. Crie um novo bloco de notas Python 3 e escreva os seguintes blocos de código:

!pip install PyDrive

Esta irá instalar o PyDrive. Agora vamos importar algumas bibliotecas necessárias:

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

Próximo, vamos criar uma variável de drive para acessar o Google Drive:

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

Para baixar o conjunto de dados, vamos usar o ID do arquivo carregado no Google Drive:

download = drive.CreateFile({'id': '1BZOv422XJvxFUnGh-0xVeSvgFgqVY45q'})

Substitua o ‘id’ no código acima com o ID do seu arquivo. Agora vamos baixar esse arquivo e descompactá-lo:

download.GetContentFile('train_LbELtWX.zip')!unzip train_LbELtWX.zip

Você tem que executar esses blocos de código toda vez que iniciar seu notebook.

Passo 2 : Importar as bibliotecas que precisaremos durante a nossa fase de construção do modelo.

import kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

Passo 3: Relembrar os passos de pré-processamento que discutimos anteriormente. Vamos usá-los aqui após carregar os dados.

train = pd.read_csv('train.csv')

Próximo, vamos ler todas as imagens de treinamento, armazená-las em uma lista, e finalmente converter essa lista em uma matriz numérica.

# We have grayscale images, so while loading the images we will keep grayscale=True, if you have RGB images, you should set grayscale as Falsetrain_image = for i in tqdm(range(train.shape)): img = image.load_img('train/'+train.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

Como é um problema de classificação multi-classe (10 classes), nós codificaremos a variável alvo.

y=train.valuesy = to_categorical(y)

Passo 4: Criando um conjunto de validação a partir dos dados de treinamento.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

Passo 5: Definindo a estrutura do modelo.

Vamos criar uma arquitetura simples com 2 camadas convolucionais, uma camada oculta densa e uma camada de saída.

model = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

Próximo, vamos compilar o modelo que criamos.

model.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

Passo 6: Treinando o modelo. Carregar as imagens de teste e prever suas classes usando a função model.predict_classes().

download = drive.CreateFile({'id': '1KuyWGFEpj7Fr2DgBsW8qsWvjqEzfoJBY'})download.GetContentFile('test_ScVgIM0.zip')!unzip test_ScVgIM0.zip

Passemos importar o arquivo de teste:

test = pd.read_csv('test.csv')

Agora, vamos ler e armazenar todas as imagens de teste:

test_image = for i in tqdm(range(test.shape)): img = image.load_img('test/'+test.astype('str')+'.png', target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

# making predictionsprediction = model.predict_classes(test)

Abriremos também um arquivo de submissão para carregar na página da plataforma DataHack (para ver como os nossos resultados se comportam na tabela de liderança).

download = drive.CreateFile({'id': '1z4QXy7WravpSj-S4Cs9Fk8ZNaX-qh5HF'})download.GetContentFile('sample_submission_I5njJSF.csv')

# creating submission filesample = pd.read_csv('sample_submission_I5njJSF.csv')sample = predictionsample.to_csv('sample_cnn.csv', header=True, index=False)

Faça o download deste ficheiro de amostra_cnn.csv e carregue-o na página do concurso para gerar os seus resultados e verificar a sua classificação na tabela de classificação. Isto lhe dará uma solução de benchmark para começar com qualquer problema de Classificação de Imagens!

Você pode tentar técnicas de ajuste e regularização de hiperparâmetros para melhorar ainda mais o desempenho do seu modelo. Eu encorajo você a conferir este artigo para entender este passo de afinação com muito mais detalhes – ‘A Comprehensive Tutorial to learn Convolutional Neural Networks from Scratch’.

Picking up a Different Challenge

Vamos testar nosso aprendizado em um conjunto de dados diferente. Nesta secção, vamos resolver o problema da prática “Identificar os Dígitos”. Vá em frente e faça o download do conjunto de dados. Antes de prosseguir, tente resolver isto por si mesmo. Você já tem as ferramentas para resolvê-lo – você só precisa aplicá-las! Volte aqui para verificar seus resultados ou se você ficar preso em algum ponto.

Neste desafio, precisamos identificar o dígito em uma determinada imagem. Nós temos um total de 70.000 imagens – 49.000 marcadas no conjunto de treinamento e as 21.000 restantes no conjunto de teste (as imagens de teste não estão marcadas). Precisamos identificar/prever a classe destas imagens não rotuladas.

Pronto para começar? Fantástico! Crie um novo caderno Python 3 e execute o seguinte código:

# Setting up Colab!pip install PyDrive

import osfrom pydrive.auth import GoogleAuthfrom pydrive.drive import GoogleDrivefrom google.colab import authfrom oauth2client.client import GoogleCredentials

auth.authenticate_user()gauth = GoogleAuth()gauth.credentials = GoogleCredentials.get_application_default()drive = GoogleDrive(gauth)

# Replace the id and filename in the below codesdownload = drive.CreateFile({'id': '1ZCzHDAfwgLdQke_GNnHp_4OheRRtNPs-'})download.GetContentFile('Train_UQcUa52.zip')!unzip Train_UQcUa52.zip

# Importing librariesimport kerasfrom keras.models import Sequentialfrom keras.layers import Dense, Dropout, Flattenfrom keras.layers import Conv2D, MaxPooling2Dfrom keras.utils import to_categoricalfrom keras.preprocessing import imageimport numpy as npimport pandas as pdimport matplotlib.pyplot as pltfrom sklearn.model_selection import train_test_splitfrom keras.utils import to_categoricalfrom tqdm import tqdm

train = pd.read_csv('train.csv')

# Reading the training imagestrain_image = for i in tqdm(range(train.shape)): img = image.load_img('Images/train/'+train, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 train_image.append(img)X = np.array(train_image)

# Creating the target variabley=train.valuesy = to_categorical(y)

# Creating validation setX_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.2)

# Define the model structuremodel = Sequential()model.add(Conv2D(32, kernel_size=(3, 3),activation='relu',input_shape=(28,28,1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(10, activation='softmax'))

# Compile the modelmodel.compile(loss='categorical_crossentropy',optimizer='Adam',metrics=)

# Training the modelmodel.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

download = drive.CreateFile({'id': '1zHJR6yiI06ao-UAh_LXZQRIOzBO3sNDq'})download.GetContentFile('Test_fCbTej3.csv')

test_file = pd.read_csv('Test_fCbTej3.csv')

test_image = for i in tqdm(range(test_file.shape)): img = image.load_img('Images/test/'+test_file, target_size=(28,28,1), grayscale=True) img = image.img_to_array(img) img = img/255 test_image.append(img)test = np.array(test_image)

prediction = model.predict_classes(test)

download = drive.CreateFile({'id': '1nRz5bD7ReGrdinpdFcHVIEyjqtPGPyHx'})download.GetContentFile('Sample_Submission_lxuyBuB.csv')

sample = pd.read_csv('Sample_Submission_lxuyBuB.csv')sample = test_filesample = predictionsample.to_csv('sample.csv', header=True, index=False)

Submeter este ficheiro na página de problemas de prática para obter um número de precisão bastante decente. É um bom começo, mas há sempre espaço para melhorias. Continue brincando com os valores do hiperparâmetro e veja se você pode melhorar no nosso modelo básico.

Notas finais

Quem disse que modelos de aprendizagem profunda exigiam horas ou dias para treinar. Meu objetivo aqui era mostrar que você pode criar um modelo de aprendizagem profunda bastante decente em tempo duplo e rápido. Você deve pegar desafios similares e tentar codificá-los a partir do seu fim também. Não há nada como aprender fazendo!

Os melhores cientistas e analistas de dados têm estes códigos prontos antes mesmo de uma Hackathon começar. Eles usam estes códigos para fazer submissões antecipadas antes mesmo de mergulhar numa análise detalhada. Uma vez que eles têm uma solução de referência, eles começam a melhorar seu modelo usando técnicas diferentes.