J'ai essayé le Deep Learning en utilisant Pylearn2. Je ne l'ai pas testé avec des données correctes, et je n'ai pas de sortie décente, donc il serait utile que vous puissiez le lire dans le but de saisir l'atmosphère de Pylearn2, "Hmm, est-ce que Pylearn2 est comme ça?" Je vais.
Veuillez vous référer au document officiel pour le moment. Une erreur peut survenir en fonction de la version de l'ano. Dans ce cas, reportez-vous au débordement de pile ci-dessous.
Pour le moment, si vous lisez le Guide de pointe de Computer Vision 6 ci-dessous, lisez les didacticiels Deep Learning et implémentez-le avec theano, vous comprendrez en quelque sorte le Deep Learning. Au fait, je ne peux que le comprendre d'une manière ou d'une autre. .. En ce qui concerne l'implémentation dans theano, il y a un article avec une explication facile à comprendre de la méthode dans le blog de sinhrks, donc je pense que cela réduira le coût d'apprentissage. De plus, Introduction à Theano par Intelligent Information Systems Co., Ltd. sera très utile. Nous vous recommandons de le lire ensemble.
Je laisse intentionnellement des commentaires pour créer un sentiment d'essais et d'erreurs. Je suis désolé, c'est difficile à voir, mais comprenez s'il vous plaît.
Créez et enregistrez toy_train.csv et toy_train.pkl (enregistrez-les en tant qu'objet série Pylearn2).
create_toy_dataset.py
import numpy
from pylearn2.datasets import DenseDesignMatrix
from pylearn2.utils import serial
class ToyDataset(DenseDesignMatrix):
def __init__(self):
rng = numpy.random.RandomState(seed=42)
data = numpy.array( [rng.randint(0,2,200) for _ in range(1000)] )
self.data = data
super(ToyDataset, self).__init__(X=data) #, y=self.y)
def main():
train = ToyDataset()
train.use_design_loc('./toy_train_design.npy')
rng = numpy.random.RandomState(seed=42)
train_csv_path = './toy_train.csv'
train_pkl_path = './toy_train.pkl'
data = numpy.array( [rng.randint(0,2,200) for _ in range(1000)] ,dtype=numpy.int)
numpy.savetxt(train_csv_path, data, delimiter=',',fmt='%d')
serial.save(train_pkl_path, train)
if __name__ == '__main__':
main()
J'ai essayé de lire le fichier csv directement et de le déplacer, mais cela n'a pas fonctionné, alors j'ai lu le fichier pkl et je l'ai utilisé. Le délimiteur du jeu de données CSV est une virgule par défaut. Si le délimiteur n'est pas spécifié dans numpy.savetxt, réécrivez le délimiteur en espace demi-largeur dans CSVDataset du fichier yaml. S'il n'y a pas d'étiquette, écrivez expect_labels: False, et s'il n'y a pas d'en-tête, écrivez expect_headers: False. Pour plus de détails, veuillez consulter le Document officiel. Concernant la structure de données lors de la création de vos propres données, [Pylearn2 I want to get started](http://laughing.hatenablog.com/entry/2013/11/30/pylearn2_%E5%85%A5%E9%96% 80% E3% 81% 97% E3% 81% 9F% E3% 81% 84% E7% B7% A8) sera utile. Comme vous pouvez le voir, le coefficient est réglé de manière appropriée, veuillez donc ne pas y faire référence. Pour la pratique du Deep Learning, j'ai résumé A Practical Guide to Training Redstricted Boltzmann Machine Deep Learning from RBM-Black Avec la magie ~ sera utile. Aussi, j'ai personnellement trouvé l'élan Mise en œuvre de l'abandon et régularisation des poids utile.
grbm_dbm.yaml
!obj:pylearn2.train.Train {
dataset: &data !obj:pylearn2.datasets.binarizer.Binarizer {
raw: &raw_train !pkl: "toy_train.pkl",
},
#dataset: &train !obj:pylearn2.datasets.csv_dataset.CSVDataset {
# path: %(path)s,
# start: %(start)i,
# stop: %(stop)i,
# expect_labels: False,
# expect_headers: False
#},
model: !obj:pylearn2.models.dbm.DBM {
batch_size: %(batch_size)i,
niter: 5,
visible_layer: !obj:pylearn2.models.dbm.BinaryVector {
nvis: %(nvis)i,
bias_from_marginals: *raw_train,
},
hidden_layers: [
!obj:pylearn2.models.dbm.BinaryVectorMaxPool {
layer_name: 'h1',
detector_layer_dim: %(detector_layer_dim1)i,
pool_size: 1,
irange: .05,
init_bias: -2.,
},
!obj:pylearn2.models.dbm.BinaryVectorMaxPool {
layer_name: 'h2',
detector_layer_dim: %(detector_layer_dim2)i,
pool_size: 1,
irange: .05,
init_bias: -2.,
},
!obj:pylearn2.models.dbm.BinaryVectorMaxPool {
layer_name: 'y',
detector_layer_dim: %(detector_layer_dim3)i,
pool_size: 1,
irange: .05,
init_bias: -2.,
}
#!obj:pylearn2.models.dbm.Softmax {
# layer_name: 'y',
# max_col_norm: 1.9365,
# #supervised: False,
# n_classes: 10,
# irange: .05,
#}
],
},
algorithm: !obj:pylearn2.training_algorithms.sgd.SGD {
learning_rate: .05,
learning_rule: !obj:pylearn2.training_algorithms.learning_rule.Momentum {
init_momentum: .5,
},
monitoring_batches: %(monitoring_batches)i,
monitoring_dataset: { 'train': *data
#'test': !obj:pylearn2.datasets.csv_dataset.CSVDataset {
# path: %(path)s,
# start: %(test_start)i,
# stop: %(test_stop)i,
# expect_labels: False,
# expect_headers: False
#},
},
cost: !obj:pylearn2.costs.cost.SumOfCosts {
costs: [
!obj:pylearn2.costs.dbm.VariationalPCD {
num_chains: 100,
num_gibbs_steps: 5
},
!obj:pylearn2.costs.dbm.WeightDecay {
coeffs: [.0001, .0001, .0001]
},
!obj:pylearn2.costs.dbm.TorontoSparsity {
targets: [.2, .2, .2],
coeffs: [.001, .001, .001],
}
],
},
termination_criterion: !obj:pylearn2.termination_criteria.EpochCounter { max_epochs: %(max_epochs)i },
update_callbacks: [
!obj:pylearn2.training_algorithms.sgd.ExponentialDecay {
decay_factor: 1.000015,
min_lr: .000001
}
]
},
extensions: [
!obj:pylearn2.training_algorithms.learning_rule.MomentumAdjustor {
final_momentum: .9,
start: 5,
saturate: 6
}
],
save_path: "%(save_path)s/grbm_dbm.pkl",
save_freq: 1
}
training J'obtiens une erreur si je ne mets pas la classe ToyDataset dans l'ensemble de données de pylearn2, mais cela semble fonctionner correctement même si je l'écris directement dans la source de formation, il y a donc une description dans le code ci-dessous (sans signification).
train_dbm.py
import os
from nose.plugins.skip import SkipTest
from theano import config
import pylearn2
from pylearn2.datasets import DenseDesignMatrix
from pylearn2.testing import skip
from pylearn2.testing import no_debug_mode
from pylearn2.utils.serial import load_train_file
from pylearn2.config import yaml_parse
class ToyDataset(DenseDesignMatrix):
def __init__(self):
rng = numpy.random.RandomState(seed=42)
data = numpy.array( [rng.randint(0,200,200) for _ in range(1000)] )
super(ToyDataset, self).__init__(X=data)#, y=self.y)
@no_debug_mode
def train_yaml(yaml_file):
train = yaml_parse.load(yaml_file)
train.main_loop()
def train(yaml_file_path, save_path):
yaml = open("{0}/grbm_dbm.yaml".format(yaml_file_path), 'r').read()
hyper_params = {'batch_size': 100,
'nvis': 200,
'detector_layer_dim1': 300,
'detector_layer_dim2': 300,
'detector_layer_dim3': 10,
'monitoring_batches': 10,
'max_epochs': 100,
'save_path': save_path}
yaml = yaml % (hyper_params)
train_yaml(yaml)
def train_dbm():
skip.skip_if_no_data()
yaml_file_path = '.'
save_path = '.'
train(yaml_file_path, save_path)
if __name__ == '__main__':
train_dbm()
dbm_result.py
import numpy as np
import pickle
import sys
import theano
from pylearn2.space import VectorSpace
from pylearn2.datasets import DenseDesignMatrix
class ToyDataset(DenseDesignMatrix):
def __init__(self):
rng = numpy.random.RandomState(seed=42)
data = numpy.array( [rng.randint(0,2,200) for _ in range(1000)] )
super(ToyDataset, self).__init__(X=data)#, y=self.y)
def simulate(inputs, model):
print dir(model)
space = VectorSpace(inputs.shape[1])
X = space.get_theano_batch()
q = model.mf(space.format_as(X, model.get_input_space()))
f = theano.function([X], q[-1])
result = []
batch_size = 100
for x in xrange(0, len(inputs), batch_size):
result.extend(f(inputs[x:x + batch_size]))
print "len:", len(result)
print result[0]
return result
def countCorrectResults(outputs):
correct = 0;
for output in outputs:
for out_vec in output:
print np.argmax(out_vec)
def score(dataset, model):
outputs = simulate(dataset.X, model)
countCorrectResults(outputs)
model = pickle.load(open('grbm_dbm.pkl')) #Modèle post-apprentissage
test_data = pickle.load(open('toy_train.pkl')) #Données utilisées pour la formation
score(test_data, model)
À la suite du déplacement du code ci-dessus, j'ai obtenu un résultat peu clair selon lequel la valeur de probabilité devient maximale à l'indice 6 pour toutes les données w J'ai l'impression que quelque chose ne va pas ou que quelque chose ne va pas du tout ..
Il y a des modules qui sont sur github mais qui ne sont pas mentionnés dans la documentation de Pylearn2, donc je pense qu'il est assez difficile de les déplacer correctement. Je ne pense pas que Pylearn2 rattrape la documentation, mais il y en a qui décrivent les grandes lignes de la méthode, alors jetez un coup d'œil rapide au document pour voir s'il y a quelque chose qui semble efficace avec une méthode que vous ne connaissez pas. , Je pense que si vous l'utilisez en lisant le papier de la méthode qui vous intéresse, vous pourrez apprendre efficacement. (Je sens juste ...)
En plus de ce que j'ai fait ci-dessus, je faisais des choses stupides et j'ai essayé de voir si je pouvais exécuter RBM sans enseignant avec MLP. Cependant, il semble que MLP n'accepte que les enseignants (une erreur se produit lors de la sonnerie monite).
Nous vous prions de nous excuser pour la gêne occasionnée, mais nous vous serions reconnaissants de bien vouloir signaler toute erreur.
Recommended Posts