[Apprentissage en profondeur] Classification d'images avec un réseau neuronal convolutif [DW jour 4]

Grosso modo

Qu'est-ce qu'AlexNet

Le réseau neuronal proposé dans l'article ci-dessous. Performances optimales dans ILSVRC 2012. Après cela, un réseau appelé VGG de l'Université d'Oxford, qui a approfondi AlexNet, est apparu et les performances ont été améliorées. (À partir de 2016, il y a GoogLeNet qui dépasse encore plus les performances. Il semble qu'il soit plus précis que les humains.)

↓ Il existe également un échantillon de Chainer.

Cette fois, j'ai écrit une version dégradée du réseau d'AlexNet et classifié les images. La raison de la détérioration est simplement de réduire le nombre de dimensions du réseau afin de résoudre le manque de mémoire.

Le réseau créé cette fois est le suivant.

class cnn(Chain):

  def __init__(self):
    super(cnn, self).__init__(
      conv1=L.Convolution2D(3, 48, 3, stride=1),
      bn1=L.BatchNormalization(48),
      conv2=L.Convolution2D(48, 128, 3, pad=1),
      bn2=L.BatchNormalization(128),
      conv3=L.Convolution2D(128, 192, 3, pad=1),
      conv4=L.Convolution2D(192, 192, 3, pad=1),
      conv5=L.Convolution2D(192, 128, 3, pad=1),
      fc6=L.Linear(2048, 1024),
      fc7=L.Linear(1024, 1024),
      fc8=L.Linear(1024, 10),
    )
    self.train = True

  def clear(self):
    self.loss = None
    self.accuracy = None

  def forward(self, x_data, t_data):
    self.clear()
    x, t = chainer.Variable(x_data, volatile=False), chainer.Variable(t_data, volatile=False)

    h = self.bn1(self.conv1(x), test=not self.train)
    h = F.max_pooling_2d(F.relu(h), 3, stride=2)
    h = self.bn2(self.conv2(h), test=not self.train)
    h = F.max_pooling_2d(F.relu(h), 3, stride=2)
    h = F.relu(self.conv3(h))
    h = F.relu(self.conv4(h))
    h = F.relu(self.conv5(h))
    h = F.max_pooling_2d(F.relu(h), 2, stride=2)
    h = F.dropout(F.relu(self.fc6(h)), train=self.train)
    h = F.dropout(F.relu(self.fc7(h)), train=self.train)
    h = self.fc8(h)

    self.loss = F.softmax_cross_entropy(h, t)
    self.accuracy = F.accuracy(h, t)

    if self.train:
      return self.loss, self.accuracy
    else:
      return h.data, self.accuracy

Comme vous pouvez le voir en le comparant avec l'échantillon Chainer, le nombre de noyaux et la taille du filtre sont réduits.

données d'image

J'ai utilisé l'ensemble de données CIFAR-10 dans ↓.

CIFAR-10 dataset

Il s'agit d'un ensemble de données avec 6000 images de 10 classes telles que des avions et des animaux par classe. La taille d'une image est de 32 $ \ fois 32 $ et elle dispose de 3 canaux RVB. Gentiment, il existe également un exemple qui lit les données avec python et les stocke dans un tableau. Cependant, la structure des données lues par cette méthode est telle que les premiers éléments $ 1024 (= 32 \ fois 32) $ sont R, le prochain $ 1024 $ est G et le prochain $ 1024 $ est B, donc Chianer Il doit être converti en une forme lisible par la fonction Convolution2D () de.

Je l'ai converti comme suit en référence au site suivant.

x_train = x_train.reshape((len(x_train), 3, 32, 32))

En outre, sur le total de 60000 $ feuilles dans la classe $ 6000 $ feuilles $ \ fois 10 $, cette fois-ci, 10000 $ feuilles ont été utilisées comme données d'entraînement et 10000 $ feuilles ont été utilisées comme données de test. L'augmentation du nombre de données d'entraînement améliorera la précision.

Évaluation des performances

Le résultat lorsque la boucle d'apprentissage est tournée de 20 époques. La précision était d'environ 56%.

Code entier

!/usr/bin/env python
 -*- coding: utf-8 -*-

__version__ = '0.0.1'

import sys
reload(sys)
sys.setdefaultencoding('utf-8')

import re
import logging
logger = logging.getLogger(__name__)
handler = logging.StreamHandler()
logger.setLevel(logging.DEBUG)
logger.addHandler(handler)

import pprint
def pp(obj):
  pp = pprint.PrettyPrinter(indent=1, width=160)
  str = pp.pformat(obj)
  print re.sub(r"\\u([0-9a-f]{4})", lambda x: unichr(int("0x"+x.group(1),16)), str)

import os, math, time

import numpy as np
import cPickle as pickle
import copy

import chainer
from chainer import cuda, Function, gradient_check, Variable, optimizers, serializers, utils, Link, Chain, ChainList
import chainer.functions as F
import chainer.links as L

import subprocess

def unpickle(f):
  import cPickle
  fo = open(f, 'rb')
  d = cPickle.load(fo)
  fo.close()
  return d

def load_cifar10(datadir, n_batch):
  train_data = []
  train_target = []

  if n_batch > 5:
    return -1

  # load train data
  for i in range(1, n_batch+1):
    d = unpickle("%s/data_batch_%d" % (datadir, i))
    train_data.extend(d["data"])
    train_target.extend(d["labels"])

  # load test data
  d = unpickle("%s/test_batch" % (datadir))
  test_data = d["data"]
  test_target = d["labels"]

  train_data = np.array(train_data, dtype=np.float32)
  train_target = np.array(train_target, dtype=np.int32)
  test_data = np.array(test_data, dtype=np.float32)
  test_target = np.array(test_target, dtype=np.int32)

  # normalization
  train_data /= 255.0
  test_data /= 255.0

  return train_data, test_data, train_target, test_target

"""
CNN with Batch-Normalization
"""

class cnn(Chain):

  def __init__(self):
    super(cnn, self).__init__(
      conv1=L.Convolution2D(3, 48, 3, stride=1),
      bn1=L.BatchNormalization(48),
      conv2=L.Convolution2D(48, 128, 3, pad=1),
      bn2=L.BatchNormalization(128),
      conv3=L.Convolution2D(128, 192, 3, pad=1),
      conv4=L.Convolution2D(192, 192, 3, pad=1),
      conv5=L.Convolution2D(192, 128, 3, pad=1),
      fc6=L.Linear(2048, 1024),
      fc7=L.Linear(1024, 1024),
      fc8=L.Linear(1024, 10),
    )
    self.train = True

  def clear(self):
    self.loss = None
    self.accuracy = None

  def forward(self, x_data, t_data):
    self.clear()
    x, t = chainer.Variable(x_data, volatile=False), chainer.Variable(t_data, volatile=False)

    h = self.bn1(self.conv1(x), test=not self.train)
    h = F.max_pooling_2d(F.relu(h), 3, stride=2)
    h = self.bn2(self.conv2(h), test=not self.train)
    h = F.max_pooling_2d(F.relu(h), 3, stride=2)
    h = F.relu(self.conv3(h))
    h = F.relu(self.conv4(h))
    h = F.relu(self.conv5(h))
    h = F.max_pooling_2d(F.relu(h), 2, stride=2)
    h = F.dropout(F.relu(self.fc6(h)), train=self.train)
    h = F.dropout(F.relu(self.fc7(h)), train=self.train)
    h = self.fc8(h)

    self.loss = F.softmax_cross_entropy(h, t)
    self.accuracy = F.accuracy(h, t)

    if self.train:
      return self.loss, self.accuracy
    else:
      return h.data, self.accuracy

if __name__ == '__main__':
  from argparse import ArgumentParser
  parser = ArgumentParser(description='RAE')
  parser.add_argument('--data_dir', type=unicode, default='', help='directory path to the cifar10 data')
  parser.add_argument('--n_data', type=int, default=1, help='# of data')
  parser.add_argument('--n_epoch', type=int, default=20, help='# of epochs')
  parser.add_argument('--batchsize', type=int, default=1, help='size of mini-batch')
  parser.add_argument('--gpu', type=int, default=-1, help='GPU ID (negative value indicates CPU)')

  args = parser.parse_args()

  """
  Get params
  """
  # the number of training itaration
  n_epoch = args.n_epoch

  # the size of mini batch
  batchsize = args.batchsize

  # define cupy
  xp = cuda.cupy if args.gpu >= 0 else np

  """
  Load data
  """
  print 'load CIFAR-10 dataset'
  x_train, x_test, y_train, y_test = load_cifar10(args.data_dir, args.n_data)

  N_train = y_train.size
  N_test = y_test.size

  print N_train, N_test

  x_train = x_train.reshape((len(x_train), 3, 32, 32))
  x_test = x_test.reshape((len(x_test), 3, 32, 32))

  """
  Prepare Acnn model
  """
  model = cnn()

  """
  Setup optimizer
  """
  optimizer = optimizers.SGD()
  optimizer.setup(model)

  """
  Setup GPU
  """
  if args.gpu >= 0:
    cuda.get_device(args.gpu).use()
    model.to_gpu()

  """
  Training Loop
  """
  for epoch in range(1, n_epoch + 1):
    print "epoch: %d" % epoch
    perm = np.random.permutation(N_train)

    sum_loss = 0
    for i in range(0, N_train, batchsize):
      x_batch = xp.asarray(x_train[perm[i:i + batchsize]])
      y_batch = xp.asarray(y_train[perm[i:i + batchsize]])

      optimizer.zero_grads()
      loss, acc = model.forward(x_batch, y_batch)
      loss.backward()
      optimizer.update()
      sum_loss += float(loss.data) * len(y_batch)

    print "train mean loss: %f" % (sum_loss / N_train)

    sum_accuracy = 0
    for i in range(0, N_test, batchsize):
      x_batch = xp.asarray(x_test[i:i + batchsize])
      y_batch = xp.asarray(y_test[i:i + batchsize])

      loss, acc = model.forward(x_batch, y_batch)
      sum_accuracy += float(acc.data) * len(y_batch)

    print "test accuracy: %f" % (sum_accuracy / N_test)

Lien

Étudiez en profondeur l'apprentissage en profondeur [DW Day 0]

Recommended Posts

[Apprentissage en profondeur] Classification d'images avec un réseau neuronal convolutif [DW jour 4]
[Apprentissage en profondeur] Découvrez comment utiliser chaque fonction du réseau neuronal convolutif [DW jour 3]
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
Classification d'images avec un réseau de neurones auto-fabriqué par Keras et PyTorch
Modèle de classification simple avec réseau neuronal
Étudiez en profondeur le Deep Learning [DW Day 0]
Deep learning 2 appris par l'implémentation (classification d'images)
[Chainer] Classification des documents par réseau de neurones convolutifs
[Python / Machine Learning] Pourquoi le Deep Learning # 1 Perceptron Neural Network
Implémenter un réseau neuronal convolutif
Expérience de réseau de neurones pliable
Analyse d'images par apprentissage profond à partir de Kaggle et Keras
[Deep Learning] Exécuter la console de réseau neuronal SONY à partir de CUI
<Cours> Apprentissage en profondeur: Day2 CNN
Réseau de neurones avec Python (scikit-learn)
3. Distribution normale avec un réseau neuronal!
<Cours> Apprentissage en profondeur: Jour 1 NN
Apprentissage profond du noyau avec Pyro
Essayez le Deep Learning avec FPGA
Réseau de neurones commençant par Chainer
Sujets> Deep Learning: Day3 RNN
4. Entourez les paramètres avec un réseau neuronal!
Chanson auto-exploitée par apprentissage en profondeur (édition Stacked LSTM) [DW Day 6]
Générez des Pokémon avec Deep Learning
Chapitre 7 [Neural Network Deep Learning] P252 ~ 275 (première moitié) [Apprenez en vous déplaçant avec Python! Nouveau manuel d'apprentissage automatique]
Classification en temps réel de plusieurs objets dans les images de la caméra avec apprentissage en profondeur de Raspberry Pi 3 B + et PyTorch
Version Lua Apprentissage profond à partir de zéro Partie 6 [Traitement d'inférence de réseau neuronal]
[Classification de texte] J'ai essayé d'implémenter des réseaux de neurones convolutifs pour la classification des phrases avec Chainer
Défiez la classification des images avec TensorFlow2 + Keras 9-Apprentissage, sauvegarde et chargement de modèles-
Identification de la race de chat avec Deep Learning
Réseau neuronal avec OpenCV 3 et Python 3
Faites de l'art ASCII avec l'apprentissage en profondeur
Essayez l'apprentissage en profondeur avec TensorFlow Partie 2
Qu'est-ce que le réseau neuronal convolutif?
[TensorFlow] [Keras] Construction d'un réseau neuronal avec Keras
Classification d'images avec un jeu de données d'images de fond d'oeil grand angle
Vérifiez la forme de squat avec l'apprentissage en profondeur
Implémentation du modèle de reconnaissance d'images d'apprentissage en profondeur 2
Catégoriser les articles de presse grâce au Deep Learning
Prévisions des ventes de collations avec apprentissage en profondeur
Faites sourire les gens avec le Deep Learning
[AI] Apprentissage en profondeur pour le débruitage d'image
Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% à l'aide du réseau neuronal convolutif TensorFlow
Mettez vos propres données d'image dans Deep Learning et jouez avec
"Classification des déchets par image!" Journal de création d'application jour3 ~ Application Web avec Django ~
Création d'un modèle de discrimination d'image (cifar10) à l'aide d'un réseau neuronal convolutif
[Rabbit Challenge (E qualification)] Apprentissage en profondeur (jour2)
Classification d'image avec Keras - Du prétraitement au test de classification -
Classez les visages d'anime avec l'apprentissage en profondeur avec Chainer
Implémentation d'un réseau neuronal à 3 couches (pas d'apprentissage)
<Cours> Deep Learning Day4 Renforcement de l'apprentissage / flux de tension
Modèle de reconnaissance d'image utilisant l'apprentissage profond en 2016
Essayez les prévisions de prix Bitcoin avec Deep Learning
Essayez avec Chainer Deep Q Learning - Lancement
Essayez d'utiliser TensorFlow-Part 2-Convolution Neural Network (MNIST)
Essayez l'apprentissage profond de la génomique avec Kipoi
Persister le réseau de neurones construit avec PyBrain