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.
Le flux global est le suivant. Je vais vous expliquer chacun en détail.
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
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,...
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'))
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.
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)
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.
Mise en œuvre Deep Learning pylearn2 dev Documentation pylearn2 in practice