Deep Learning::Usando a Nuvem para seus Trabalhos

Nesta página vamos mostrar como você, mesmo sem recursos para um computador com uma boa GPU em casa, pode realizar todos os trabalhos da Disciplina e treinar suas redes neurais e seus modelos de aprendizado de máquina com tranqüilidade. Para isso vamos apresentar uma série de tutoriais sobre Plataformas de Treinamento de Redes Neurais em Nuvem (foram brevemente descritas anteriormente). Nesta página vamos focar em plataformas que você vai poder, na prática, usar sem problemas daqui da UFSC ou de sua casa.  Faremos isso acessando colaboratórios em nuvem.

A definição de Collaboratory (aqui com dois “ll”s) é um “center without walls, in which the nation’s researchers can perform their research without regard to physical location, interacting with colleagues, accessing instrumentation, sharing data and computational resources, [and] accessing information in digital libraries” (William Allan Wulf, pesquisador em Computação, Universidade da Virgínia, 1989). 

Google Colaboratory

Para usar o Google Collaboratory você necessita apenas ter uma conta Google. Para criar seu colaboratório próprio, simplesmente esteja logado em sua conta Google em seu browser e acesse: https://colab.research.google.com. Vai abrir a página mostrada abaixo, com 3 laboratórios já predefinidos:

Gcollab-1
 

Agora você tem de decidir como vai trabalhar. Há três opções:

  • Usando PyTorch e fast.ai
  • Usando TensorFlow puro
  • Usando Keras ou outra coisa não diretamente suportada.

Além disso você tem de decidir como vai disponibilizar seus dados para treinamento. Isso é importante pois datasets normalmente são grandes e pode ser que sua conta no Google Colab não suporte o espaço necessário. Há algumas opções aqui:

  • GoogleDrive: o Google Colaboratory oferece 3 formas diferentes de você usar dados a partir do seu Drive. É a forma mais simples, uma vez que você terá um bom espaço para seus dados no Google Drive, a velocidade de conexão é por conta da Google e você pode usá-los diretamente no colaboratory, além de mantê-los sincronizados com a sua máquina em casa;
  • Upload de datasets diretamente no Colaboratory.

Por último, você tem de decidir como vai gerenciar seu código fonte. Aqui há duas opções:

  • Projetos simples e pequenos: gerencie todo o seu código diretamente dentro dos Jupyter Notebooks oferecidos pelo Colaboratory;
  • Projetos maiores: Colaboratory oferece uma integração com GitHub.

Projetos-Exemplo com Google Colaboratory

O que faremos neste projetos exemplo? Vamos trabalhar a detectção de imagens mais simples, porém melhor do que letrinhas mNIST que todo mundo usa. Usaremos o “Dogs vs. Cats” dataset do Kaggle, que contém 25.000 images. Vamos trabalhar com um subset de 2.000 imagens disponível no exemplo de Keras abaixo.

Vamos, para cada uma das três plataformas adiante tentar produzir uma tarefa de treinamento de redes neurais para classificar gatos e cachorros, como no exemplo de Satya Mallick e Vikas Gupta em Learn OpenCV e no artigo de fine tuning Using pre-trained Imagenet models dos mesmos autores.

Como fazer Google Colab usar GPU ou outra versão de Python?

Depois de criar um novo projeto, vá para o menu Runtime -> Change Runtime Type e selecione o que você deseja, como mostra a figura abaixo:

colab-gpu

A FAQ detalha restrições: https://research.google.com/colaboratory/faq.html#gpu-availability

Posso rodar ainda mais rápido? Usando TPUs

Você deve ter visto que, além de “nenhuma” (= CPU)  e “GPU”, há uma terceira opção de hardware de aceleração gráfica, “TPU”, para seus notebooks no Colab:

colab-tpu

Chengwei Zhang, em seu artigo Medium::How to train Keras model x20 times faster with TPU for free discute uma forma de você usar a plataforma de TPUs da Google para rodar os seus Colab Notebooks. Existem alguns detalhes aos quais você tem de estar atento. No exemplo de Chengwei Zhang, o código usado é Keras. Supostamente roda até 20x mais rápido do que em uma NVidia GTX 1070. 

O que são TPUs?

Os tensor processing units (TPU) são aceleradores para IA desenvolvidos pela Google em um circuito específico para este tipo de aplicação (ASIC – circuitos orientados para implementação de tarefas específicas em domínios bem definidos), ao contrário das GPUs onde, ao processar tensores nelas, estamos de fato executando um desvio de função de shaders gráficos. A função dos TPUs é oferecer uma plataforma específica para Machine Learning. Segundo a CIO, TPU é a base para o processamento dos recursos de Machine Learning presentes em aplicativos como o Google Fotos e também nas APIs disponibilizadas para os clientes de Google Cloud Platform.

tpu

A ideia de processadores específicos para IA não é nova: na década de 1980 empresas como Symbolics e Lisp Machines produziam “máquinas LISP“, que eram processadores paralelos especialmente voltados ao processamento de listas, a base da IA simbólica da época, e que possuíam sistemas operacionais que integravam de forma transparente linguagens funcionais como LISP.  A figura abaixo mostra uma Symbolics de meados da década de 1980:

Symbolics3640_Modified

É interessante observar que a linguagem de escolha para CNNs, Python, é uma moderna linguagem funcional que possui Tuplas, Listas e Dicionários como a base para as suas estruturas de dados mais complexas.

Como saber se minha Arquitetura de Rede é Compatível com TPU?

O TensorBoard possui uma função denominada TPU Compatibility  onde é provida uma análise gráfica da sua arquitetura de rede e a sua compatibilidade com TPUs. Abra o TensorBoard a partir do Google Colab como explicamos e vá para Graphs e depois selecione TPU Compatibility no modo de visualização:

tpu-compat

Como saber se a GPU está sendo usada?

Crie uma célula no notebook e faça assim:

import tensorflow as tf
tf.test.gpu_device_name()

colab-gpu-2

Como saber a versão de CUDA e qual a GPU?

Crie uma célula no notebook e faça assim:

!/opt/bin/nvidia-smi
!nvcc --version

Obs.: Linhas de código precedidas de “!” são consideradas linhas de comando do bash do Linux subjacente.

colab-gpu-3

Aqui você pode ver:

  • GPU: Tesla K80
  • Driver: 396.44
  • CUDA: 9.2

Como eu descubro a versão de Linux e a arquitetura da máquina do Colab?

Crie uma célula no notebook e faça assim:

!uname -a
!cat /etc/lsb-release

colab-linux

Aqui você pode ver:

  • Arquitetura: AMD 64
  • Multiprocessamento: SMP
  • Linux: Ubuntu 18.04
  • Kernel: 4.14.65

Usando tensorFlow.Keras

IMPORTANTE: Esta seção vai ensinar coisas básicas de Google Colaboratory além de mostrar como você pode trabalhar com a API de compatibilidade tensorFlow -> Keras. Se você nunca usou Google Colab, aqui há muitos toques e receitas de bolo que são independentes do framework de Deep Learning que você escolheu: TensorFlow, Keras, PyTorch ou TensorFlow.Keras. Por isso é importante que você faça este tutorial daqui primeiro.

Para trabalhar com Keras há um exemplo pronto na Internet em: Cat vs. Dog Image Classification – Google Colab. Este exemplo é parte de um treinamento que continua com Data Augmentation e Dropout na Parte 2.

Comece abrindo o Jupyter da Lição 1 (lembre-se de antes logar-se em sua conta Google que está associada ao Google Drive que você pretende usar para seus dados).  Crie agora uma cópia sua clicando em “Copy to Drive” ao alto, no meio da página. Deverá aparecer agora uma cópia do Jupyter marcada como tal:

colab-keras-1

Agora você está pronto para executar as tarefas que há ali.

Como eu executo um código Python em Google Colab?

Basta clicar no ícone “Play” no lado esquero superior da caixinha de workspace Python e o código será executado. A saída (stdout) da execução é mostrada em outra janela de texto imediatamente abaixo do workspace:

colab-keras-2

Agora basta fazer o mesmo com as próximas células de workspace…. Os projetos em Google Colab são Jupyter Notebooks praticamente idênticos aos da plataforma padrão e funcionam do mesmo jeito: saída gráfica é redirecionada para o canvas da página. A célula que faz mostrar os cães e gatos produz o seguinte resultado:

colab-keras-3

Diferenças de Keras Tradicional

Nas próximas células vai surgir um código que é diferente dos códigos tradicionas de Keras em Python. Isso acontece porque neste caso, rodando as coisas na plataforma da Google, vamos usar uma reimplementação de Keras em tensorFlow que foi produzida para que se pudesse rodar código de alto nível desenvolvido para Keras diretamente em tensorFlow e em ambiente Google:

Quando usamos Keras em Google Colab, importamos as bibliotecas de Keras da seguinte forma:

from tensorflow.keras import layers
from tensorflow.keras import Model

colab-keras-4

Treinando uma Rede com tensorFlow.Keras

Você pode usar o mesmo método Model.fit do Keras. O Jupyter vai mostrar a saída renderizada na página:

colab-keras-5

Visualizando Representações Intermediários

Uma vantagem de se usar Jupyter Notebooks é que você pode criar rotinas para visualizar as representações intermediárias da rede sem poluir o seu monitor com dezenas de janelas abertas por Matplotlib. O exemplo incluso neste notebook deixa isso claro:

colab-keras-6

Plotando Curvas em Google Colab

Por fim plote a curácia do seu treinamento. Novamente os resultados serão renderizados diretamente no canvas da página do notebook:

colab-keras-7

Vamos aogra pegar este exemplo e criar algo novo com o que aprendemos?

Criando uma Nova Aplicação com tensorFlow e Keras

Vamos criar uma aplicação que usa os mesmos dados, mas realizar fine tuning de uma rede VGG pré-treinada com eles. Vá para File -> New Python3 Notebook e crie uma nova aplicação com Python3.  Chame-a de fine-tuning.ipynb, editando o nome ao alto:

colab-keras-8

Nós vamos usar a integração do Google Colab com o Google Drive para fazer o próximo exemplo. Para isso temos de colocar dados em uma localização em seu Drive. Copie a linha de download do exemplo de cães e gatos acima e execute-a em sua linha de comando, em seu computador:

wget --no-check-certificate https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip

Em seguida descompacte o arquivo cats_and_dogs_filtered.zip. Sem pânico: são JPGs e não vai aumentar o tamanho. Queremos gerar a árvore de diretórios em seu drive que você vai montar como disco no Google Colab:  Assim você não necessita copiar os dados para um local temporário no Colab toda vez que for executar o código.

Uma vez extraída a estrutura do ZIP, abra o seu Drive e empurre a árvore inteira para lá:

cats_and_dogs_filtered
- train
  - cats
  - dogs
- validation
  - cats
  - dogs

Vamos agora ver como montamos uma pasta do Google Drive como disco no Google Colab.

Usando Dados em seu Google Drive

Vamos pegar alguns toques do livro de receitas de bolo para datasets do Google Collab: https://colab.research.google.com/notebooks/io.ipynb. Nós vamos usar o método #3 sugerido: Montar uma pasta do Google Drive como disco local em seu Google Collab:

Suponha que você salvou a árvore de diretória acima em My Drive/data: basta referenciar isto. Google automaticamente, como você está logado, procurar na sua conta do Drive.

O nosso código para as pastas de treino e de validação agora ficará assim:

import os

# Codigo para montar o Google Drive
from google.colab import drive
drive.mount('/content/gdrive')
base_dir = '/content/gdrive/My Drive/data/cats_and_dogs_filtered'
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')

Para ver se deu certo, inclua código para imprimir os nomes das pastas e, a seguir crie variáveis com cada diretório de exemplos em separado, como fizemos no exempo anterior:

print(train_dir)
print(validation_dir)
# Directory with our training cat pictures
train_cats_dir = os.path.join(train_dir, 'cats')

# Directory with our training dog pictures
train_dogs_dir = os.path.join(train_dir, 'dogs')

# Directory with our validation cat pictures
validation_cats_dir = os.path.join(validation_dir, 'cats')

# Directory with our validation dog pictures
validation_dogs_dir = os.path.join(validation_dir, 'dogs

colab-keras-9

A primeira coisa que vai acontecer quando você executar esse código é ser gerado um link para você autorizar acesso ao Google Drive. Abra o link em outra aba e faça o que pede lá, colando a chave de acesso no campo Enter authorization code:

colab-drive

 Em seguida o resto do código será executado. Isso só é necessário uma vez. Agora seu Drive está habilitado.

Agora vamos criar uma nova célula (menu “+ CODE” no alto da página) e mandar imprimir os nomes dos primeiros 10 arquivos de gatos e de cães para ver se deu tudo certo e o Colab está realmente acessando o conteúdo do Drive. Lembre-se ao copiar o código do exemplo anterior, de que este notebook aqui usa Python3 e a função print é com parênteses print():

train_cat_fnames = os.listdir(train_cats_dir)
print(train_cat_fnames[:10])

train_dog_fnames = os.listdir(train_dogs_dir)
train_dog_fnames.sort()
print(train_dog_fnames[:10])

Agora terá de ter sido gerada uma saída similar à da figura abaixo:

colab-keras-10

Se deu certo, então o seu Drive está acessível do seu Colab e você pode usá-lo para disponibilizar de forma confortável seus datasets. Vamos agora continuar e criar um modelo masi complexo do que o do exemplo anterior.

Se você quiser você pode criar mais células repetindo o código usado no xemplo anterior para mostrar as imagens. Este código você pode copiar sem alteração alguma e não vamos exemplificar aqui.

Realizando Fine Tuning com Keras no Google Colab

Para esta parte do exemplo, vamos nos basear no tutorial de aprendizado pro transferência de Satya Mallick: https://www.learnopencv.com/keras-tutorial-transfer-learning-using-pre-trained-models/  Vamos agora importar Keras e a rede pré-treinada VGG16 de Keras.Applications, realizando isto através de API Keras de tensorFlow, aproveitando para instancia a rede:

from tensorflow.keras import layers
from tensorflow.keras import Model
from tensorflow.keras.applications import VGG16

vgg_conv = VGG16(weights='imagenet',
                  include_top=False,
                  input_shape=(224, 224, 3)

Execute este código. Você vai observar que, da primeira vez, será baixado o arquivo de pesos da rede pré-treinada do GitHub de Keras:

colab-keras-11

Parabéns, você instanciou uma rede VGG16 sem o topo! O topo é a parte backpropagation-padrão que faz o mapeamento final das características para as classes. 

Vamos agora criar um gerados de dados e percorrer os dados de treino com ele. Observe que aqui o código é um pouco diferente do exemplo de Mallick: tensorFlow.Keras difere de Keras original em algus detalhes; O gerador, por exemplo, não possui shuffle:

# Importar o gerador de dados de treino e teste
from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Importar NumPy
import numpy as np

# Guardar número de cães e gatos...
nTrain = 2000
nVal = 1000

datagen = ImageDataGenerator(rescale=1./255)
batch_size = 20
 
train_features = np.zeros(shape=(nTrain, 7, 7, 512))
train_labels = np.zeros(shape=(nTrain,2))
 
train_generator = datagen.flow_from_directory(
    train_dir,
    target_size=(224, 224),
    batch_size=batch_size,
    class_mode='categorical')

colab-keras-12

Agora gere predições para os seus dados de treino (vai demorar):

 

Feito isto, insira uma nova célula para gerar as predições para os dados de teste, colando o seguinte código:

validation_features = np.zeros(shape=(nVal, 7, 7, 512))
validation_labels = np.zeros(shape=(nVal,2))

validation_generator = datagen.flow_from_directory(
    validation_dir,
    target_size=(224, 224),
    batch_size=batch_size,
    class_mode='categorical')

i = 0
for inputs_batch, labels_batch in validation_generator:
    features_batch = vgg_conv.predict(inputs_batch)
    validation_features[i * batch_size : (i + 1) * batch_size] = features_batch
    validation_labels[i * batch_size : (i + 1) * batch_size] = labels_batch
    i += 1
    if i * batch_size >= nVal:
        break

validation_features = np.reshape(validation_features, (nVal, 7 * 7 * 512))

…e execute este código também….

  • train_features  e validation_features são as coleções dos vetores de características das imagens processadas pelo “núcleo” da rede VGG. Você pode guardá-los como lotes e usá-los para treinar e valicar as novas camadas de saída que você vai criar a seguir.

Agora você pode criar a sua rede e mostrá-la, criando mais uma célula, agora com o seguinte código:

from tensorflow.keras import layers
from tensorflow import keras 
import tensorflow as tf
from tensorflow.keras import optimizers

model = keras.Sequential()  # Observe que esta linha é diferente de Keras puro!

model.add(layers.Dense(512, activation='relu', input_dim=7 * 7 * 512))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(2, activation='softmax'))

model.compile(optimizer=optimizers.RMSprop(lr=2e-4),
              loss='categorical_crossentropy',
              metrics=['acc'])

model.summary()

colab-keras-19

e agora inclua:

history = model.fit(train_features,
                    train_labels,
                    epochs=20,
                    batch_size=batch_size,
                    validation_data=(validation_features,validation_labels))

…e treine a rede:

colab-keras-20

Para plotar os gráficos de aprendizado veja: Plotando_Curvas_em_Google_Colab

Usando Keras puro

Vamos repetir o exemplo de cães & gatos baseado em Satya Mallick aqui para você. Você vai ver que é possível usar Keras puro (com tensorFlow como backend automático, sem necessidade de carga explícita) no Google Colab.

Vamos criar uma aplicação que usa os mesmos dados, mas realizar fine tuning de uma rede VGG pré-treinada com eles. Vá para File -> New Python3 Notebook e crie uma nova aplicação com Python3.  Chame-a de testeKeras.ipynb, editando o nome ao alto:

colab-keras-8

Importando elementos Básicos de Keras e Rede VGG16

Nesta versão do tutorial você vai poder praticamente copiar todas as células do Jupyter transfer-learning-vgg.ipynb de Satya Mallick.

Comece criando duas células para as inicializaçãoes que você necessita e para importar a rede VGG16 de keras.applications:

import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from __future__ import print_function
import keras
from keras.utils import to_categorical
import os
from keras.preprocessing.image import ImageDataGenerator, load_img

import sys
print(sys.version)

e:

from keras.applications import VGG16

vgg_conv = VGG16(weights='imagenet',
                  include_top=False,
                  input_shape=(224, 224, 3))

Observe que, como este é um novo notebook, os pesos da rede vão ser baixados uma segunda vez, mesmo que você tenha feito o nosso tutorial anterior:

colab-keras-13

Para verificar se a rede instanciou corretamente, solicite a impressão de um sumário:

vgg_conv.summary()

colab-keras-14

Agora vamos acessar os nosso dados de treino. Para tanto repita as ações do tutorial passado:

Montando e Acessando o Dataset no seu Google Drive

Nós vamos usar a integração do Google Colab com o Google Drive para fazer também este exemplo. Para isso temos de colocar dados em uma localização em seu Drive. Se você não fez o opie a linha de download do exemplo de cães e gatos acima e execute-a em sua linha de comando, em seu computador:

wget --no-check-certificate https://storage.googleapis.com/mledu-datasets/cats_and_dogs_filtered.zip

Em seguida descompacte o arquivo cats_and_dogs_filtered.zip. Sem pânico: são JPGs e não vai aumentar o tamanho. Queremos gerar a árvore de diretórios em seu drive que você vai montar como disco no Google Colab:  Assim você não necessita copiar os dados para um local temporário no Colab toda vez que for executar o código.

Uma vez extraída a estrutura do ZIP, abra o seu Drive e empurre a árvore inteira para lá:

cats_and_dogs_filtered
- train
  - cats
  - dogs
- validation
  - cats
  - dogs

Vamos agora ver como montamos uma pasta do Google Drive como disco no Google Colab.

Vamos pegar alguns toques do livro de receitas de bolo para datasets do Google Collab: https://colab.research.google.com/notebooks/io.ipynb. Nós vamos usar o método #3 sugerido: Montar uma pasta do Google Drive como disco local em seu Google Collab:

Suponha que você salvou a árvore de diretória acima em My Drive/data: basta referenciar isto. Google automaticamente, como você está logado, procurar na sua conta do Drive.

O nosso código para as pastas de treino e de validação agora ficará assim:

import os

# Codigo para montar o Google Drive
from google.colab import drive
drive.mount('/content/gdrive')

# Código para os nomes das pastas de treino e validação
base_dir = '/content/gdrive/My Drive/data/cats_and_dogs_filtered'
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')

# Directory with our training cat pictures
train_cats_dir = os.path.join(train_dir, 'cats')

# Directory with our training dog pictures
train_dogs_dir = os.path.join(train_dir, 'dogs')

# Imprimir
print(train_dir)
print(validation_dir)

# Imprimir nomes dos arquivos
train_cat_fnames = os.listdir(train_cats_dir)
print(train_cat_fnames[:10])

train_dog_fnames = os.listdir(train_dogs_dir)
train_dog_fnames.sort()
print(train_dog_fnames[:10])

Se você tiver de autorizar acesso ao Drive, faça como no exemplo anterior e cole o link. Depois disso o resto do código deverá ser executado e você verá 20 nomes de arquivos sendo impressos:

colab-keras-15

Gerando conjuntos características de treinamento e validação

Por que eu faço assim? Não parece estranho?  Veja aqui a explicação: Deep Learning::Aprendizado por Transferência e Ajuste Fino.

Resumo: No aprendizado por transferência você apenas retira os camadas que não deseja de uma rede pronta e coloca novas camadas sobre esta rede. Você vai treinar apenas estas novas camadas. Uma estratégia bastante eficiente para esse treinamento é você deixar as duas redes separadas e simplesmente passar todos os padrões de treinamento e de validação uma vez apenas pela “parte de baixo” da rede (a parte que você não vai modificar), guardar a resposta da rede “velha” para cada uma destes padrões e usar estas respostas como entradas para treinar apenas as novas camadas de “topo” que você adicionou à saída da rede. Isso economiza uma quantidade enorme de processamento, pois a “parte de baixo” da rede (provavelmente aquela que é de longe a mais complexa) só vai processar cada padrão uma única vez.  A desvantagem é que você necessita de memória adicional para armazenar estes padrões de saída: se a camada de saída dessa rede truncada que você criou possuir 4096 neurônios, então você vai ter de armazenar n padrões de dimensão 1 x 4096 onde n é o tamanho do conjunto de treinamento… 

Use o seguinte código para gerar os conjuntos características de treinamento e validação, criando duas novas células no notebook:

nTrain = 2000
nVal = 1000

datagen = ImageDataGenerator(rescale=1./255)
batch_size = 20

train_features = np.zeros(shape=(nTrain, 7, 7, 512))
train_labels = np.zeros(shape=(nTrain,2))

train_generator = datagen.flow_from_directory(
    train_dir,
    target_size=(224, 224),
    batch_size=batch_size,
    class_mode='categorical',
    shuffle=True)

i = 0
for inputs_batch, labels_batch in train_generator:
    features_batch = vgg_conv.predict(inputs_batch)
    train_features[i * batch_size : (i + 1) * batch_size] = features_batch
    train_labels[i * batch_size : (i + 1) * batch_size] = labels_batch
    i += 1
    if i * batch_size >= nTrain:
        break
        
train_features = np.reshape(train_features, (nTrain, 7 * 7 * 512))

…e depois para a validação:

validation_features = np.zeros(shape=(nVal, 7, 7, 512))
validation_labels = np.zeros(shape=(nVal,2))

validation_generator = datagen.flow_from_directory(
    validation_dir,
    target_size=(224, 224),
    batch_size=batch_size,
    class_mode='categorical')

i = 0
for inputs_batch, labels_batch in validation_generator:
    features_batch = vgg_conv.predict(inputs_batch)
    validation_features[i * batch_size : (i + 1) * batch_size] = features_batch
    validation_labels[i * batch_size : (i + 1) * batch_size] = labels_batch
    i += 1
    if i * batch_size >= nVal:
        break

validation_features = np.reshape(validation_features, (nVal, 7 * 7 * 512))

colab-keras-16

Criando e Treinando o Novo Topo da Rede VGG para Cães e Gatos

Crie agora uma célula para você montar seu “topo de rede treinável”:

from keras import models
from keras import layers
from keras import optimizers

model = models.Sequential()
model.add(layers.Dense(512, activation='relu', input_dim=7 * 7 * 512))
model.add(layers.Dropout(0.5))
model.add(layers.Dense(2, activation='softmax'))

model.compile(optimizer=optimizers.RMSprop(lr=2e-4),
              loss='categorical_crossentropy',
              metrics=['acc'])

..e mais uma célula para treinar (vamos querer guardar a históreia de treinamento para mostrar – olhe o tutorial de Satya Malick para detalhes sobre as razões para esse código):

history = model.fit(train_features,
                    train_labels,
                    epochs=20,
                    batch_size=batch_size,
                    validation_data=(validation_features,validation_labels))

Agora treine e olhe o resultado:

colab-keras-17

Pronto! Você treinou a rede!

Plotando Curvas em Google Colab

Agora vamos aproveitar a capacidade dos Jupyter Notebooks de renderizarem qualquer saída gráfica diretamente para o canvas da página plotando as curvas de aprendizado e erro da rede, similarmente ao que fizemos na primeira parte do exemploa acima. Para isso vamos usar a variável history que criamos antes e que guardou o progresso da rede:

# Plot the accuracy and loss curves
acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(len(acc))

plt.plot(epochs, acc, 'b', label='Training acc')
plt.plot(epochs, val_acc, 'r', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()

plt.figure()

plt.plot(epochs, loss, 'b', label='Training loss')
plt.plot(epochs, val_loss, 'r', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()

plt.show()

colab-keras-18

Usando PyTorch e fast.ai

Usar PyTorch com fast.ai no Google Colab tem seus truques: você tem de olhar bem quais versões vai usar. O nosso pesquisador Luiz Eduardo Ramos de Carvalho preparou um Jupyter Notebook em Google Colab com todos os detalhes necessários para que funcione diretinho, incluindo a opção de baixar o dataset de cães de gatos diretamente no Colab:

Fast.ai tem um acordo com o provedor de processamento em nuvem Paperspace e, se você for fazer os tutoriais que eles propõem, do jeito que propõem, você vai parar no site de Paperspace e com uma oferta de uma conta paga para rodar as suas coisas.

…mas existe uma solução: Google Colab agora também está suportando a a API de fast.ai. Isso significa que, com algumas inicializações de seu ambiente no Colab, você pode simplesmente tomar os tutoriais que estão no fast.ai e copiar o código para o seu Colab.

Aqui instruções um pouco defasadas: Towards Data Science::Fast.ai Lesson 1 on Google Colab (Free GPU).

Instalando fast.ai no Colab

Testei várias maneiras e essa combinação de versões abaixo é o que está funcionando em Novembro de 2018. Crie uma célula a faça:

!pip install http://download.pytorch.org/whl/cu75/torch-0.3.0.post4-cp36-cp36m-linux_x86_64.whl  && pip install torchvision
!pip install "fastai==0.7.0"
!pip install torchtext==0.2.3

colab-fastai-1

Agora instale algumas coisas necessárias (nessas versões aí):

!pip install Pillow==4.0.0
!pip install PIL
!pip install image

Lembre-se de não apagar estas células: toda vez que você desconecta do Colab, a sua máquina virtual é destruída e esta sua instalação vai para o brejo e tem de ser reptida da próxima vez que você usar este notebook.

Não deu certo?

Google sugere instalar PyTorch da seguinte forma:

# http://pytorch.org/
from os.path import exists
from wheel.pep425tags import get_abbr_impl, get_impl_ver, get_abi_tag
platform = '{}{}-{}'.format(get_abbr_impl(), get_impl_ver(), get_abi_tag())
cuda_output = !ldconfig -p|grep cudart.so|sed -e 's/.*\.\([0-9]*\)\.\([0-9]*\)$/cu\1\2/'
accelerator = cuda_output[0] if exists('/dev/nvidia0') else 'cpu'

!pip install -q http://download.pytorch.org/whl/{accelerator}/torch-0.4.1-{platform}-linux_x86_64.whl torchvision
import torch

Reconhecendo Cães e Gatos com PyTorch e fast.ai

Nós vamos nos basear no curso padrão do fast.ai:  https://course.fast.ai/lessons/lesson1.html

Para começar, você precisa ter os Jupyter Notebooks do curso. eja aqui no nosso link retrabalhado:

O notebook acima baixa o dataset diretamente. Se você quiser usar um dataset próprio ou os cães e gatos que você já tem no seu Drive, você tem de substituir a parte onde são baixados so dados no notebook acima por nossa parte de Usando Dados em seu Google Drive, acima, lembrando que a estrutrura de diretório em fast.ai tem alguns nomes pré-definidos e você tem de adaptar esse exemplo.

Material adicional sobre fast.ai em nuvem

Hiromi Suenaga publicou uma série de comentários e toques adicionais sobre os dois capítulos do Curso de Deep Learning com Jupyters de fast.ai. Possuem muitos insights e toques úteis, além de discutir detalhes da implementação de fast.ai que não estão nas aulas originais:

  1. Medium::Deep Learning 2: Part 1 Lesson 1
  2. Medium::Deep Learning 2: Part 2 Lesson 8

 

Usando TensorFlow puro

Em produção…

construction

 

Kernels no Kaggle

A plataforma de Competições de Ciência de Dados e Aprendizado de Máquina Kaggle também oferece um ambiente de Jupyter Notebooks denominado Kernel.

Como fazer?

  1. Vá para https://www.kaggle.com/
  2. Crie uma conta lá, pode ser com a sua conta Google como referência ou com a sua conta da UFSC;
  3. Siga os passos, inclusive a autenticação de dois fatores via SMS;
  4. Use um Kernel de algum tutorial (você pode ver muitos exemplos do própro Kaggle aqui: https://www.kaggle.com/kernels) ou crie um Kernel: você vai ou cair em um Jupyter Notebook contendo tarefas prontas ou então em um Jupyter novinho baseado em Python3.

 

Microsoft Azure

A UFSC possui um acordo com a Microsoft que oferece acesso limitado à plataforma Azure da Microsoft para estudantes (100 horas de processamento). Para ativar o seu acesso você tem de acessar https://ufsc.onthehub.com com o seu IDUFSC e escolher o Azure dentro os produtos que vão ser sugeridos na página de entrada do programa de parceria. Uma vez selecionado o Azure, você vai ver a seguinte página:

Azure-1
 Adicione ao seu carrinho e siga as instruções a seguir. Após algumas páginas você terá de criar uma conta Microsoft associada ao seu e-mail institucional da UFSC. Preencha a seguinte página e continue:

Azure-2

Crie uma conta no Outlook associada ao seu e-mail da UFSC, entre nesta conta e, em seguida, preencha seus dados para o SMS de validação:

Azure-3

Depois de você entrar com o código enviado por SMS, você verá a seguinte página:

Azure-4

Nesta página não há um acesso direto ao Microsoft Azure Machine Learning Studio, que é o que nós queremos.  Sem sair da sua conta Outlook ou Live.com, acesse https://azure.microsoft.com/en-us/services/machine-learning-studio/.  Talvez você tenha de se logar novamente. Faça-o.

Pronto. Agora sim:

Azure-CNN-0

Nesta página você pode criar:

  • Projetos (ícone do Erlenmeyer)
  • Jupyter Notebook (ícone do bloquinho de notas)

Sempre crie através do “+” na base da página, lembrando de primeiramente selecionar o que você deseja criar através da aba esquerda (a ou b acima). A figura acima mostra um projeto-exemplo de MNIST. Observe que aqui Azure oferece uma interface de programação visual associada a arquivos de configuração. Exemplificamos a associação entre um bloco de programação visual e a configuração da CNN abaixo:

Azure-CNN-0a

Azure tem uma sintaxe própria para esses arquivos. Clique no ícone das pagininhas ao alto da caixinha mostrada pela flecha acima e você cai no editor de configuração:

Azure-CNN-1

Se você não gosta disso, uma solução mais tradicional é usar Jupyter Notebook. Esse você não cria como projetos , mas sim como notebooks simplesmente. Abaixo um exemplo de um notebook-exemplo de aprendizado de máquina:

Azure-ML-1

Aqui Azure oferece templates de Jupyters para Python 2 e para Python 3.

O que é Microsoft Azure Machine Learning Studio?

  1. Site: https://azure.microsoft.com/en-us/services/machine-learning-studio/
  2. Possui uma ferramenta: Azure AI -Artificial intelligence productivity for virtually every developer and scenario
  3. Exemplo: Defect detection with image analysis

Copyright © 2018 Aldo von Wangenheim/INCoD/Universidade Federal de Santa Catarina

188
Unique
Visitors
Powered By Google Analytics

 

 

 

 

Sobre o Autor

possui graduação em Ciências da Computação pela Universidade Federal de Santa Catarina (1989) e Doutorado Acadêmico (Dr. rer.nat.) em Ciências da Computação pela Universidade de Kaiserslautern (1996). Atualmente é professor Associado da Universidade Federal de Santa Catarina, onde é professor do Programa de Pós-graduação em Ciência da Computação e dos cursos de graduação em Ciências da Computação e Sistemas de Informação. É também professor e orientador de doutorado do Programa de Pós-Graduação em Ciências da Computação da Universidade Federal do Paraná - UFPR. Tem experiência nas áreas de Produção de Conteúdo para TV Digital Interativa, Informática em Saúde, Processamento e Análise de Imagens e Engenharia Biomédica, com ênfase em Telemedicina, Telerradiologia, Sistemas de Auxílio ao Diagnóstico por Imagem e Processamento de Imagens Médicas, com foco nos seguintes temas: analise inteligente de imagens, DICOM, CBIR, informática médica, visão computacional e PACS. Coordena o Instituto Nacional de Ciência e Tecnologia para Convergência Digital - INCoD. É também Coordenador Técnico do Sistema Integrado Catarinense de Telemedicina e Telessaúde (STT/SC), coordenador do Grupo de Trabalho Normalização em Telessaúde do Comitê Permanente de Telessaúde/Ministério da Saúde e membro fundador e ex-coordenador da Comissão Informática em Saúde da ABNT - ABNT/CEET 00:001.78. Atualmente também é membro da comissão ISO/TC 215 - Health Informatics. Foi coordenador da RFP6 - Conteúdo - do SBTVD - Sistema Brasileiro de TV Digital/Ministério das Comunicações. Foi o criador e primeiro Coordenador do Núcleo de Telessaúde de Santa Catarina no âmbito do Programa Telessaúde Brasil do Ministério da Saúde e da OPAS - Organização Pan-Americana de Saúde e criador do Núcleo Santa Catarina da RUTE - Rede Universitária de Telemedicina.