Mettez vos propres données d'image dans Deep Learning et jouez avec

L'apprentissage automatique est utilisé dans divers services de nos jours. Parmi eux, la méthode appelée Deep Learning attire l'attention en tant que méthode haute performance. Dans cet article, j'écrirai sur la façon d'exécuter réellement le Deep Learning à l'aide d'une bibliothèque d'apprentissage automatique de LISA-Lab appelée pylearn2. La cible est un fichier image.

Il semble qu'il existe de nombreux articles pour exécuter le tutoriel de pyleran2, mais il semble qu'il n'y ait presque aucune information écrite au point d'apprendre les données créées par moi-même, donc "Deep Learning" ou "pylearn2" est incroyable. Je comprends, mais c'est pour les gens qui ne savent pas comment l'utiliser. J'omettrai les parties d'installation, d'utilisation et de tutoriel de pylearn2.

De plus, je pense qu'il existe différentes méthodes, mais voici un exemple.

procédure

Le flux global est le suivant. Je vais vous expliquer chacun en détail.

  1. Convertissez le fichier image en fichier CSV
  2. Convertissez CVS en pkl
  3. Apprendre
  4. Test d'identification

Préparation

Cette fois, le répertoire de travail est créé à l'emplacement suivant sous le répertoire de pylearn2. J'expliquerai que tous les fichiers manipulés cette fois sont essentiellement placés directement sous ce répertoire.

pylearn2/pylearn2/script/tutorials/sample

J'emprunterai également le script pour lire et tester l'ensemble de données CSV tel qu'il est publié dans pylearn2 in practice. Vous pouvez le télécharger depuis la page GitHub avec un lien en bas de page.

Après le téléchargement, mettez "adult_dataset.py" à l'intérieur dans le répertoire suivant.

pylearn2/pylearn2/datasets

Convertir le fichier image en fichier CSV

Commencez par convertir le fichier image en fichier CSV. Toutes les données d'image à entraîner sont sorties sous forme de données CSV. Comme le montre l'exemple ci-dessous, la règle CSV consiste à séparer chaque image en une seule ligne, le début en tant que classe d'appartenance et les parties suivantes en tant que données de pixel avec une virgule ",". Bien sûr, vous pouvez le changer plus tard même s'il ne s'agit pas d'une virgule, mais ici nous l'expliquerons par une virgule.

train.csv


classe,Données de pixel 1,Données de pixel 2,Données de pixel 3,...
classe,Données de pixel 1,Données de pixel 2,Données de pixel 3,...
classe,Données de pixel 1,Données de pixel 2,Données de pixel 3,...
...

Peu importe comment vous le faites, mais j'ai utilisé OpenCV pour l'instant. À titre d'exemple, cela ressemble à ceci. Par souci de simplicité, nous avons inclus 200 images nommées en séquence, les 100 premières étant de classe 0 et les 100 dernières de classe 1. Cette fois, il s'agit d'une classification à deux classes, mais vous pouvez l'augmenter davantage, veuillez donc l'augmenter avec un entier si nécessaire. Modifiez cette zone au besoin.

main.cpp


int main() {
	FILE *fp = fopen("train.csv", "w");
    Iplimage *input = cvLoadImage("trainingImage.png ", CV_LOAD_IMAGE_GRAYSCALE);
    
    int numFiles = 200;
    int numFirstClass = 100;
    
    for(int i=0; i<numFiles; i++) {
    
        if(i<numFirstClass) fprintf(fp, "0");
        else                fprintf(fp, "1");
    
        for (int y = 0; y < input->height; y++) {
            for (int x = 0; x < input->width; x++) {
                uchar pixelValue = 0;
                pixelValue = (uchar)input->imageData[y*input->width+x];
                fprintf(fp, ",%d", (int)pixelValue);
            }
        }
        fprintf(fp, "\n");
    }
}

Un fichier comme celui-ci sera créé (les valeurs numériques sont des exemples). Il devrait y avoir 200 lignes au total. Placez le fichier créé dans le répertoire de travail.

0,13,15,18,41,11,...
0,19,40,50,31,23,...
...
...
1,135,244,210,15,150,...
1,45,167,84,210,100,...

Convertir CSV en pkl

Convertissez le CSV créé en fichier pkl afin qu'il puisse être facilement manipulé par python. La source ressemble à ceci.

python


from pylearn2.datasets.adult_dataset import AdultDataset
import pickle

print 'convert: train.csv -> train.pkl'
pyln_data = AdultDataset('train.csv',one_hot=True)
pickle.dump(pyln_data, open('train.pkl', 'w'))

Apprendre

Maintenant que les données sont prêtes, formons-les. Le réseau à créer cette fois-ci est un réseau à 3 couches avec 2 couches d'AutoEncoder et une couche de régression Softmax comme discriminateur.

Le yaml de chaque couche ressemble à ceci. Puisque les nombres qui peuvent être définis arbitrairement sont approximatifs, modifiez chaque paramètre si nécessaire. Ce qui est important c'est

--nvis: nombre d'unités d'entrée. Le premier calque doit avoir le même nombre de pixels que l'image et le second calque doit avoir le même nombre d'unités (nhid) que le calque caché du premier calque. --n_Classes: nombre de classes de sortie. Spécifiez le nombre de classes que vous souhaitez classer. Dans cet exemple, 2.

Donc, si cela n'est pas défini correctement, il n'apprendra pas en premier lieu, donc si cela ne fonctionne pas, vous voudrez peut-être vérifier si vous avez fait une erreur ici, ou si vous avez fait une erreur au stade de la création du fichier CSV. Hmm.

Les résultats de pré-entraînement pour les première et deuxième couches sont envoyés vers DAE_l1.pkl et DAE_l2.pkl.

dae_l1.yaml


!obj:pylearn2.train.Train {
    dataset: &train !pkl: "train.pkl",

    model: !obj:pylearn2.models.autoencoder.DenoisingAutoencoder {
        nvis : 200,
        nhid : 100,
        irange : 0.05,
        corruptor: !obj:pylearn2.corruption.BinomialCorruptor {
            corruption_level: .1,
        },
        act_enc: "tanh",
        act_dec: null,    # Linear activation on the decoder side.
    },
    algorithm: !obj:pylearn2.training_algorithms.sgd.SGD {
        learning_rate : 1e-3,
        batch_size : 5,
        monitoring_batches : 1,
        monitoring_dataset : *train,
        cost : !obj:pylearn2.costs.autoencoder.MeanSquaredReconstructionError {},
        termination_criterion : !obj:pylearn2.termination_criteria.EpochCounter {
            max_epochs: 10,
        },
    },
    save_path: "DAE_l1.pkl",
    save_freq: 1
}

dae_l2.yaml


!obj:pylearn2.train.Train {
    dataset: &train !obj:pylearn2.datasets.transformer_dataset.TransformerDataset {
        raw: !pkl: "train.pkl",
        transformer: !pkl: "DAE_l1.pkl"
    },
    model: !obj:pylearn2.models.autoencoder.DenoisingAutoencoder {
        nvis : 100,
        nhid : 20,
        irange : 0.05,
        corruptor: !obj:pylearn2.corruption.BinomialCorruptor {
            corruption_level: .2,
        },
        act_enc: "tanh",
        act_dec: null,    # Linear activation on the decoder side.
    },
    algorithm: !obj:pylearn2.training_algorithms.sgd.SGD {
        learning_rate : 1e-3,
        batch_size : 5,
        monitoring_batches : 1,
        monitoring_dataset : *train,
        cost : !obj:pylearn2.costs.autoencoder.MeanSquaredReconstructionError {},
        termination_criterion : !obj:pylearn2.termination_criteria.EpochCounter {
            max_epochs: 10,
        },
    },
    save_path: "DAE_l2.pkl",
    save_freq: 1
}

dae_mlp.yaml


!obj:pylearn2.train.Train {
    dataset: &train !pkl: "train.pkl",

    model: !obj:pylearn2.models.mlp.MLP {
        batch_size: 5,
        layers: [
                 !obj:pylearn2.models.mlp.PretrainedLayer {
                     layer_name: 'h1',
                     layer_content: !pkl: "DAE_l1.pkl"
                 },
                 !obj:pylearn2.models.mlp.PretrainedLayer {
                     layer_name: 'h2',
                     layer_content: !pkl: "DAE_l2.pkl"
                 },
                 !obj:pylearn2.models.mlp.Softmax {
                     layer_name: 'y',
                     n_classes: 2,
                     irange: 0.05
                 }
                ],
        nvis: 200
    },
    algorithm: !obj:pylearn2.training_algorithms.sgd.SGD {
        learning_rate: .05,
        learning_rule: !obj:pylearn2.training_algorithms.learning_rule.Momentum {
            init_momentum: .5,
        },
        monitoring_dataset:
            {
                'valid' : *train,
            },
        cost: !obj:pylearn2.costs.mlp.Default {},
        termination_criterion: !obj:pylearn2.termination_criteria.And {
            criteria: [
                !obj:pylearn2.termination_criteria.MonitorBased {
                    channel_name: "valid_y_misclass",
                    prop_decrease: 0.,
                    N: 100
                },
                !obj:pylearn2.termination_criteria.EpochCounter {
                    max_epochs: 50
                }
            ]
        },
        update_callbacks: !obj:pylearn2.training_algorithms.sgd.ExponentialDecay {
            decay_factor: 1.00004,
            min_lr: .000001
        }
    },
    extensions: [
        !obj:pylearn2.training_algorithms.learning_rule.MomentumAdjustor {
            start: 1,
            saturate: 250,
            final_momentum: .7
        }
    ],
    save_path: "mlp.pkl",
    save_freq: 1
}

Lorsque yaml est prêt, exécutez le script suivant pour l'entraîner.

train.py


from pylearn2.config import yaml_parse
import os
import pickle

def train_step(config_file):
    assert(os.path.exists(config_file))
    _yaml = open(config_file).read()
    _train = yaml_parse.load(_yaml)
    _train.main_loop()
    return _train

l1_train = train_step('dae_l1.yaml')
l2_train = train_step('dae_l2.yaml')
_train = train_step('dae_mlp.yaml')

Une fois exécuté, un fichier appelé "mlp.pkl" sera généré. Puisqu'il s'agit du résultat d'apprentissage, nous l'utiliserons ensuite pour effectuer un test d'identification.

Test d'identification

La méthode de création des données de test est la même que celle des données d'entraînement, et l'image est convertie en un fichier CSV-> pkl. Ici, c'est "test.pkl".

python


from pylearn2.datasets.adult_dataset import AdultDataset
import pickle

print 'convert: test.csv -> test.pkl'
pyln_data = AdultDataset('test.csv', one_hot=True)
pickle.dump(pyln_data, open('test.pkl', 'w'))

Vous pouvez exécuter un script comme celui-ci pour afficher le nombre de données de test identifiées comme la classe correcte.

test.py


import numpy as np
import pickle
import theano

# function for classifying a input vector
def classify(inp,model,input_size):
    inp = np.asarray(inp)
    inp.shape = (1, input_size)
    return np.argmax(model.fprop(theano.shared(inp, name='inputs')).eval())
 
# function for calculating and printing the models accuracy on a given dataset
def score(dataset, model, input_size):
    nr_correct = 0
    for features, label in zip(dataset.X,dataset.y):
        if classify(features,model, input_size) == np.argmax(label):
            nr_correct += 1
    print '{}/{} correct'.format(nr_correct, len(dataset.X))
    return nr_correct, len(dataset.X)

model = pickle.load(open('mlp.pkl'))
test_data = pickle.load(open('test.pkl'))
score(test_data, model, 200)

fin

Comme mentionné ci-dessus, je pense que vous pouvez tout faire, de l'apprentissage au test en utilisant vos propres données. J'ai remarqué en cours de route, mais il semble que pylearn2 contient également un script de lecture (pylearn2 / pylearn2 / datasets / csv_dataset.py) qui prend en charge les ensembles de données CSV, vous pouvez donc l'utiliser.

Matériaux référencés et matériaux de référence

Mise en œuvre Deep Learning pylearn2 dev Documentation pylearn2 in practice

Recommended Posts

Mettez vos propres données d'image dans Deep Learning et jouez avec
Créons un modèle de reconnaissance d'image avec vos propres données et jouons!
Développez et gonflez votre propre ensemble de données Deep Learning
Analyse d'images par apprentissage profond à partir de Kaggle et Keras
Reconnaissez votre patron avec Deep Learning et masquez l'écran
Apprentissage par renforcement 23 Créez et utilisez votre propre module avec Colaboratory
Prenez une image avec Pepper et affichez-la sur votre tablette
Introduction au Deep Learning (2) - Essayez votre propre régression non linéaire avec Chainer-
[Renforcer l'apprentissage] DQN avec votre propre bibliothèque
Modèle de reconnaissance d'image utilisant l'apprentissage profond en 2016
Créez votre propre PC pour un apprentissage en profondeur
Mettez Linux dans Chromebook et utilisez R ...
Générer et publier des données d'image factice avec Django
Entraînez Stanford NER Tagger avec vos propres données
[Apprentissage automatique] Créez un modèle d'apprentissage automatique en effectuant un apprentissage par transfert avec votre propre ensemble de données
Collectez vous-même des données d'image de formation au machine learning (API de recherche personnalisée Google Pikachu)
Collectez vous-même des données d'image de formation au machine learning (API Tumblr Yoshioka Riho ed.)
Créez votre propre Big Data en Python pour validation
Mettez les données AWS dans Google Spreadsheet avec boto + gspread
Essayez de mettre des LED dans votre propre PC (légèrement)
Prédire les tags en extrayant des fonctionnalités musicales avec Deep Learning
POSTER l'image avec json et la recevoir avec flask
Comment dessiner de manière interactive un pipeline d'apprentissage automatique avec scikit-learn et l'enregistrer au format HTML
Renvoyez les données d'image avec Flask of Python et dessinez-les dans l'élément canvas de HTML
Mettez Ubuntu dans Raspi, mettez Docker dessus et contrôlez GPIO avec python à partir du conteneur
Comment utiliser pyenv et pyenv-virtualenv à votre manière
Où dans l'apprentissage en profondeur, le produit matriciel / produit interne est utilisé
Prétraitement dans l'apprentissage automatique 3 Données de valeur manquante / aberrante / de déséquilibre
[Jouons avec Python] Traitement d'image en monochrome et points
[Apprentissage en profondeur] Classification d'images avec un réseau neuronal convolutif [DW jour 4]
Jouez avec les archives de Mastodon dans les réponses et les favoris de Python 2 Count
Apprentissage en profondeur avec Shogi AI sur Mac et Google Colab
Installez CaboCha dans l'environnement Ubuntu et appelez-le avec Python.
HIKAKIN et Max Murai avec vidéo de jeu en direct et apprentissage en profondeur
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
Essayez l'apprentissage en profondeur avec TensorFlow
Reconnaissance d'image par apprentissage profond 1 théorie
Apprentissage profond du noyau avec Pyro
Essayez le Deep Learning avec FPGA
Tweet avec image en Python
Générez des Pokémon avec Deep Learning
traitement pour utiliser les données notMNIST en Python (et essayé de les classer)
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 11
Apprentissage en profondeur avec Shogi AI sur Mac et Google Colab Chapitres 1 à 6
Avec l'apprentissage en profondeur, vous pouvez dépasser le taux de récupération de 100% dans les courses de chevaux
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 8
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 7
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 10 6-9
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 10
Créez votre propre classe de structure graphique et son dessin avec python
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 7 5-7
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 9
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3
Défiez la classification des images avec TensorFlow2 + Keras 9-Apprentissage, sauvegarde et chargement de modèles-
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 3
Deep Learning avec Shogi AI sur Mac et Google Colab Chapitre 12 1-2
[Introduction au style GAN] Apprentissage unique de l'animation avec votre propre machine ♬