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.

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

Recommended Posts

Apprentissage automatique pour apprendre avec Nogisaka 46 et Keyakizaka 46 Partie 1 Introduction
Introduction à l'apprentissage automatique
[Python] Introduction facile à l'apprentissage automatique avec python (SVM)
[Super introduction à l'apprentissage automatique] Découvrez les didacticiels Pytorch
[Super introduction à l'apprentissage automatique] Découvrez les didacticiels Pytorch
Une introduction à l'apprentissage automatique
Super introduction à l'apprentissage automatique
Résumé du site pour apprendre l'apprentissage automatique avec une vidéo en anglais
Mémo d'apprentissage Python pour l'apprentissage automatique par Chainer Chapitres 11 et 12 Introduction à Pandas Matplotlib
Introduction à la rédaction de notes d'apprentissage automatique
Introduction à l'apprentissage automatique avec scikit-learn - De l'acquisition de données à l'optimisation des paramètres
Présentation de la bibliothèque d'apprentissage automatique SHOGUN
[Introduction au style GAN] Apprentissage unique de l'animation avec votre propre machine ♬
Introduction à l'apprentissage automatique: fonctionnement du modèle
Prédire la demande de puissance avec l'apprentissage automatique, partie 2
Introduction au Deep Learning ~ Pliage et mise en commun ~
Une introduction à OpenCV pour l'apprentissage automatique
Une introduction à Python pour l'apprentissage automatique
[Introduction à l'apprentissage automatique] Jusqu'à ce que vous exécutiez l'exemple de code avec chainer
Les débutants en Python publient des applications Web à l'aide de l'apprentissage automatique [Partie 2] Introduction à Python explosif !!
Une introduction à l'apprentissage automatique pour les développeurs de robots
Apprentissage automatique à partir de Python Personal Memorandum Part2
Apprentissage automatique à partir de Python Personal Memorandum Part1
[Pour les débutants] Introduction à la vectorisation dans l'apprentissage automatique
Ingénierie des fonctionnalités pour l'apprentissage automatique à partir de la partie 2 Conversion de Google Colaboratory-Logistic et conversion Box-Cox
Introduction à PyQt4 Partie 1
Apprenez en quelque sorte le machine learning
J'ai essayé de déplacer l'apprentissage automatique (détection d'objet) avec TouchDesigner
Machine learning facile avec AutoAI (partie 4) Jupyter Notebook
Apprentissage automatique avec Raspberry Pi 4 et Coral USB Accelerator
Apprenez le filtrage collaboratif avec les supports Coursera Machine Learning
J'ai essayé d'implémenter et d'apprendre DCGAN avec PyTorch
Apprentissage automatique facile avec scikit-learn et flask ✕ Application Web
Essayez de prédire le taux de change (FX) avec un apprentissage automatique non approfondi
Intelligence artificielle, machine learning, deep learning pour mettre en œuvre et comprendre
L'apprentissage automatique pratique avec Scikit-Learn et TensorFlow-TensorFlow a abandonné -
[Comment!] Apprenez et jouez à Super Mario avec Tensorflow !!
Introduction à l'apprentissage automatique à partir de Simple Perceptron
[Apprentissage automatique] Démarrez Spark avec iPython Notebook et essayez MLlib
Bulletin de formation recommandé par MS Learn, numéro de février [Introduction à l'IA]
Introduction facile au piratage domestique avec Raspberry Pi et discord.py
[Introduction à cx_Oracle] (Partie 6) Mappage des types de données DB et Python
L'apprentissage automatique appris avec Pokemon
[Mémorandum d'apprentissage] Introduction à vim
Comment créer un environnement virtuel Anaconda à utiliser avec Azure Machine Learning et comment créer un lien avec Jupyter
Ne pas apprendre avec la séquence TensorFlow ~ Fibonacci de la bibliothèque d'apprentissage automatique
Créez un environnement d'apprentissage automatique scikit-learn avec VirtualBox et Ubuntu
[Introduction à cx_Oracle] (Partie 4) Récupération et défilement du jeu de résultats
Les débutants en Python publient des applications Web à l'aide de l'apprentissage automatique [Partie 1] Introduction
Comment dessiner de manière interactive un pipeline d'apprentissage automatique avec scikit-learn et l'enregistrer au format HTML
Apprentissage automatique avec Python! Préparation
Introduction à RDB avec sqlalchemy Ⅰ
Mémos personnels et liens liés à l'apprentissage automatique ③ (BI / visualisation)
Pour ceux qui souhaitent démarrer l'apprentissage automatique avec TensorFlow2
Super introduction à l'apprentissage automatique Modèle probabiliste et estimation la plus probable
Démineur d'apprentissage automatique avec PyTorch
Introduction au Deep Learning ~ Règles d'apprentissage ~
Apprentissage automatique et optimisation mathématique
Ingénierie des fonctionnalités pour l'apprentissage automatique à partir de la partie 3 Échelle collaborative de Google