[PYTHON] Apprentissage automatique pour apprendre avec Nogisaka 46 et Keyakizaka 46 Partie 1 Introduction

Tout d'abord, en me présentant, je suis un élève de 4e année qui fréquente une université scientifique à Tokyo, et puisque je vais faire des études supérieures, je serai un moratoire pour les 2 prochaines années ＞ ＜ Je recherche un emploi stagiaire à temps partiel dans une entreprise comme l'apprentissage automatique lol, si vous avez un service du personnel, veuillez me contacter lol J'entends souvent le mot apprentissage automatique / IA, que j'entends souvent dans le monde, dans mon laboratoire, mais je pense comprendre un peu la théorie, "CNN? RNN? Pliage? Machine Boltzmann? Normalisation?" Je ne l'ai jamais fait auparavant, donc je pense que je vais essayer de créer une IA basée sur mon "Nogisaka 46 / Keyakizaka 46" préféré. Ma valeur d'expérience est presque 0, donc j'espère que vous pouvez le voir comme un graffiti de débutant. Je voudrais écrire profondément sur les idoles à la fin lol

1. Quoi faire

Si vous ne vous fixez pas d'objectif sur quoi faire, cela ne démarrera pas, alors fixez-vous un objectif. Dans mon interprétation, l'apprentissage automatique est une compréhension égoïste d'une fonction qui renvoie «un étiquetage probabiliste» à partir d'un «ensemble de données». Alors, quand j'ai pensé à créer une IA basée sur Nogizaka et Keyakizaka, j'ai eu l'idée d'une "IA qui classe et enregistre automatiquement les membres sur la photo du membre" lol J'ai pensé que ce serait bien d'avoir une IA qui déterminerait qui chante dans quelle partie lorsqu'une chanson est insérée, mais comme je n'ai pas encore compris la reconnaissance vocale, j'aimerais l'essayer une fois l'identification de l'image terminée. pense.

2. Faire de l'IA

Maintenant que nous nous sommes fixé comme objectif de créer une "IA qui classe et enregistre automatiquement les membres sur la photo du membre", je voudrais choisir les moyens d'atteindre cet objectif. Il existe de nombreux frameworks tels que TensorFlow, Chainer et Caffe que j'entends souvent dans le domaine de l'apprentissage automatique, mais cette fois, j'aimerais créer une IA similaire avec tensorflow et Chainer et les comparer. J'ai entendu dire que Caffe est installé en tant que démon, alors j'ai évité Caffe lol

3. Construction de l'environnement

J'aimerais donc installer Python, tensorflow, Chainer sur mon PC. De nombreuses personnes ont publié des articles à ce sujet, je vais donc l'omettre cette fois. Si vous les lisez pour référence, vous pourrez peut-être installer les trois ci-dessus sur votre propre PC.

• Installer TensorFlow à partir de la construction de l'environnement Python ・ [Création d'un environnement d'apprentissage "machine learning" en utilisant Python sur Mac] (http://qiita.com/yoshizaki_kkgk/items/4663148a2b3ca078ddbc)
• Méthode de construction de l'environnement de développement TensorFlow (1.0.0) (Mac) Sur mon PC, j'ai installé Python sur mon Mac en utilisant Homebrew et Python en utilisant pyenv, et j'ai installé tensorflow, Chainer et anaconda (qui mettent divers modules tels que numpy dans un lot). Si vous voulez introduire cela à partir du premier état propre, lancez le mot ci-dessus à google et je pense qu'il existe un article plus détaillé, veuillez donc vous y référer et l'introduire.

J'ai pu l'installer en toute sécurité comme ça.

4. Essayez de reconnaître les nombres

Depuis que j'ai introduit TensorFlow et Chainer, je vais essayer de le démontrer, en confirmant qu'il fonctionne réellement correctement avec les données numériques MNIST. MNIST est presque toujours la première chose qui apparaît dans le domaine de l'apprentissage automatique, et est un ensemble de données de nombres manuscrits. Jetez-les dans des frameworks tels que TensorFlow et Chainer pour voir s'ils peuvent être appris et identifiés. Il n'y a presque pas de tâche difficile comme Hello World lors de l'apprentissage dans d'autres langues, alors j'aimerais le faire (il est difficile de comprendre la théorie) Le code réel ressemble à ceci:

tf_mnist.py

import argparse
import sys

from tensorflow.examples.tutorials.mnist import input_data

import tensorflow as tf

FLAGS = None


def main(_):
  #Lire les données
  mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)

  #Déclarez les entrées, les pondérations, les biais et les sorties. 784=28*28, 1 pixel 1 bit d'entrée
  x = tf.placeholder(tf.float32, [None, 784])
  W = tf.Variable(tf.zeros([784, 10]))
  b = tf.Variable(tf.zeros([10]))
  y = tf.matmul(x, W) + b

  #Variable y pour saisir la réponse lors du calcul de l'entropie croisée_Déclarer
  y_ = tf.placeholder(tf.float32, [None, 10])
  #Calculer l'entropie croisée
  cross_entropy = tf.reduce_mean(
      tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
  train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

  sess = tf.InteractiveSession()
  tf.global_variables_initializer().run()
  #Apprentissage
  for _ in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})

  #Calculez le taux de réponse correct entre la réponse réelle et le modèle d'apprentissage
  correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
  print(sess.run(accuracy, feed_dict={x: mnist.test.images,
                                      y_: mnist.test.labels}))

if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
                      help='Directory for storing input data')
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

ch_mnist.py

from __future__ import print_function

import argparse

import chainer
import chainer.functions as F
import chainer.links as L
from chainer import training
from chainer.training import extensions

#Définir un réseau de neurones
class MLP(chainer.Chain):

    def __init__(self, n_units, n_out):
        super(MLP, self).__init__()
        with self.init_scope():
            # the size of the inputs to each layer will be inferred
            self.l1 = L.Linear(None, n_units)  # n_in -> n_units
            self.l2 = L.Linear(None, n_units)  # n_units -> n_units
            self.l3 = L.Linear(None, n_out)  # n_units -> n_out

    def __call__(self, x):
        h1 = F.relu(self.l1(x))
        h2 = F.relu(self.l2(h1))
        return self.l3(h2)


def main():
    #Prescrire les paramètres sur la ligne de commande
    parser = argparse.ArgumentParser(description='Chainer example: MNIST')
    parser.add_argument('--batchsize', '-b', type=int, default=100,
                        help='Number of images in each mini-batch')
    parser.add_argument('--epoch', '-e', type=int, default=20,
                        help='Number of sweeps over the dataset to train')
    parser.add_argument('--frequency', '-f', type=int, default=-1,
                        help='Frequency of taking a snapshot')
    parser.add_argument('--gpu', '-g', type=int, default=-1,
                        help='GPU ID (negative value indicates CPU)')
    parser.add_argument('--out', '-o', default='result',
                        help='Directory to output the result')
    parser.add_argument('--resume', '-r', default='',
                        help='Resume the training from snapshot')
    parser.add_argument('--unit', '-u', type=int, default=1000,
                        help='Number of units')
    args = parser.parse_args()

    print('GPU: {}'.format(args.gpu))
    print('# unit: {}'.format(args.unit))
    print('# Minibatch-size: {}'.format(args.batchsize))
    print('# epoch: {}'.format(args.epoch))
    print('')

    # Set up a neural network to train
    # Classifier reports softmax cross entropy loss and accuracy at every
    # iteration, which will be used by the PrintReport extension below.
    model = L.Classifier(MLP(args.unit, 10))
    if args.gpu >= 0:
        # Make a specified GPU current
        chainer.cuda.get_device_from_id(args.gpu).use()
        model.to_gpu()  # Copy the model to the GPU

    # Setup an optimizer
    optimizer = chainer.optimizers.Adam()
    optimizer.setup(model)

    #Le train d'initialisation des données et les données de test sont préparés
    train, test = chainer.datasets.get_mnist()

    #Si vous mettez des données ici dans l'itérateur, il procédera à l'apprentissage
    train_iter = chainer.iterators.SerialIterator(train, args.batchsize)
    test_iter = chainer.iterators.SerialIterator(test, args.batchsize,
                                                 repeat=False, shuffle=False)

    # Set up a trainer
    updater = training.StandardUpdater(train_iter, optimizer, device=args.gpu)
    trainer = training.Trainer(updater, (args.epoch, 'epoch'), out=args.out)

    # Evaluate the model with the test dataset for each epoch
    trainer.extend(extensions.Evaluator(test_iter, model, device=args.gpu))

    # Dump a computational graph from 'loss' variable at the first iteration
    # The "main" refers to the target link of the "main" optimizer.
    trainer.extend(extensions.dump_graph('main/loss'))

    # Take a snapshot for each specified epoch
    frequency = args.epoch if args.frequency == -1 else max(1, args.frequency)
    trainer.extend(extensions.snapshot(), trigger=(frequency, 'epoch'))

    # Write a log of evaluation statistics for each epoch
    trainer.extend(extensions.LogReport())

    # Save two plot images to the result dir
    if extensions.PlotReport.available():
        trainer.extend(
            extensions.PlotReport(['main/loss', 'validation/main/loss'],
                                  'epoch', file_name='loss.png'))
        trainer.extend(
            extensions.PlotReport(
                ['main/accuracy', 'validation/main/accuracy'],
                'epoch', file_name='accuracy.png'))

    # Print selected entries of the log to stdout
    # Here "main" refers to the target link of the "main" optimizer again, and
    # "validation" refers to the default name of the Evaluator extension.
    # Entries other than 'epoch' are reported by the Classifier link, called by
    # either the updater or the evaluator.
    trainer.extend(extensions.PrintReport(
        ['epoch', 'main/loss', 'validation/main/loss',
         'main/accuracy', 'validation/main/accuracy', 'elapsed_time']))

    # Print a progress bar to stdout
    trainer.extend(extensions.ProgressBar())

    if args.resume:
        # Resume from a snapshot
        chainer.serializers.load_npz(args.resume, trainer)

    # Run the training
    trainer.run()


if __name__ == '__main__':
    main()

C'est celui du tutoriel TensorFlow, Chainer, et si vous demandez à l'enseignant Google, il tombera immédiatement lol Le résultat a été produit comme suit, et il a été confirmé que TensorFlow et Chainer étaient capables d'apprendre fermement les nombres manuscrits.

la prochaine fois

La prochaine fois, j'aimerais publier un article sur la collecte d'ensembles de données pour la reconnaissance d'image réelle. J'espère que vous pourrez le lire.

finalement

Il n'est pas exagéré de dire que j'ai posté cette fois parce que je voulais écrire ce lol Je suis un otaku d'un dollar chassant Nogisaka 46 et Keyakizaka46, mais les hommes recommandés sont Midsummer Akimoto, Miri Watanabe et __Fumiho Kato __ (1 recommandé). Veuillez me contacter si vous avez la chance de rencontrer toutes les performances live lol ← J'ai participé à pas mal de performances live lol, mais j'écrirai plus à ce sujet la prochaine fois, donc je l'omettrai cette fois. Je n'ai pas du tout serré la main w S'agit-il de l'auto-introduction sur la pente? .. .. Les événements prévus pour participer à la guerre sont tous Tsu Niigata et Tokyo Dome (prévu). Récemment, l'élan des membres de la 3e génération est si grand que je ne peux pas du tout obtenir de billet. J'ai supprimé AiiA, qui est le troisième mandat seulement, et la princesse qui m'a tué, alors s'il vous plaît, faites diverses choses avec la direction. (Moi aussi, je prends fermement le 3e terme de prise individuelle lol) Je compte empiler le ticket de poignée de main de Kato Fumiho le 5 de Keyaki, merci à Toshi-chan. L'opération de Qiita est une censure stricte, mais si cet article est supprimé, je le posterai à nouveau lol