Verwenden Sie Pylearn2 für die handschriftliche Zeichenerkennung. Ich werde die Installationsmethode von Pylearn2 weglassen. Legen Sie die Umgebungsvariable PYLEARN2_VIEWER_COMMAND fest, um das Bild anzuzeigen.

Der diesmal verwendete Quellcode wurde auf Github hochgeladen. https://github.com/dsanno/pylearn2_mnist

Daten herunterladen

Verwenden Sie die MNIST-Datenbank für Daten. Es hat den folgenden Datensatz.

Ein Datenelement ist ein 28 x 28 Pixel großes Schwarzweißbild mit einer der gezeichneten Zahlen von 0 bis 9.
60000 Trainingsdaten
10000 Testdaten

pylearn2 enthält Skripte, die einige Datensätze herunterladen und verarbeiten. Führen Sie zum Herunterladen der MNIST-Datenbank die folgende in pylearn2 enthaltene Datei aus. Die heruntergeladenen Daten werden in $ PYLEARN2_DATA_PATH / mnist abgelegt. pylearn2/scripts/datasets/download_mnist.py

Überprüfen Sie die Daten

Lassen Sie uns überprüfen, welche Art von Daten enthalten sind.

Erstellen Sie zunächst eine Yaml-Datei, die das Dataset definiert.

`dataset.yaml`


!obj:pylearn2.datasets.mnist.MNIST {
    which_set: 'train'
}

Verwenden Sie dann show_examples.py in pylearn2, um ein Beispiel der Daten anzuzeigen. Erstellen Sie die folgende Datei und führen Sie sie aus.

`show_samples.py`


import pylearn2.scripts.show_examples as show_examples

show_examples.show_examples('dataset.yaml', 20, 20)

Alternativ kann es mit dem folgenden Befehl angezeigt werden. pylearn2/scripts/show_examples.py dataset.yaml

Das folgende Bild wird angezeigt.

Definieren Sie ein Modell

Definieren Sie ein Modell für das Training. Im Verzeichnis stacked_autoencoders des Lernprogramms befindet sich ein Modell zum Trainieren von MNIST-Daten. Ändern Sie es also und verwenden Sie es. pylearn2/scripts/tutorals/stacked_autoencoders/

Dieses Mal werden wir das folgende Modell definieren.

Die Eingabe beträgt 28 x 28 = 784 Einheiten
Die Ausgabe beträgt 10 Einheiten
3 versteckte Schichten
Jeweils 100 Einheiten für versteckte Ebenen

Schicht: 28 x 28 = Nimmt 784 Eingabewerte an.

`dae_l1.yaml`


!obj:pylearn2.train.Train {
    dataset: &train !obj:pylearn2.datasets.mnist.MNIST {
        which_set: 'train',
        start: 0,
        stop: %(train_stop)i
    },
    model: !obj:pylearn2.models.autoencoder.DenoisingAutoencoder {
        nvis : 784,
        nhid : %(nhid)i,
        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 : %(batch_size)i,
        monitoring_batches : %(monitoring_batches)i,
        monitoring_dataset : *train,
        cost : !obj:pylearn2.costs.autoencoder.MeanSquaredReconstructionError {},
        termination_criterion : !obj:pylearn2.termination_criteria.EpochCounter {
            max_epochs: %(max_epochs)i,
        },
    },
    save_path: "%(save_path)s/dae_l1.pkl",
    save_freq: 1
}

Zweite Schicht: Verwenden Sie für den Datensatz die Trainingsdaten, die von der ersten Ebene konvertiert wurden.

`dae_l2.yaml`


!obj:pylearn2.train.Train {
    dataset: &train !obj:pylearn2.datasets.transformer_dataset.TransformerDataset {
        raw: !obj:pylearn2.datasets.mnist.MNIST {
            which_set: 'train',
            start: 0,
            stop: %(train_stop)i
        },
        transformer: !pkl: "%(save_path)s/dae_l1.pkl"
    },
    model: !obj:pylearn2.models.autoencoder.DenoisingAutoencoder {
        nvis : %(nvis)i,
        nhid : %(nhid)i,
        irange : 0.05,
        corruptor: !obj:pylearn2.corruption.BinomialCorruptor {
            corruption_level: .3,
        },
        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 : %(batch_size)i,
        monitoring_batches : %(monitoring_batches)i,
        monitoring_dataset : *train,
        cost : !obj:pylearn2.costs.autoencoder.MeanSquaredReconstructionError {},
        termination_criterion : !obj:pylearn2.termination_criteria.EpochCounter {
            max_epochs: %(max_epochs)i,
        },
    },
    save_path: "%(save_path)s/dae_l2.pkl",
    save_freq: 1
}

Dritte Schicht: Verwenden Sie für den Datensatz die Trainingsdaten, die von der ersten und zweiten Ebene konvertiert wurden.

!obj:pylearn2.train.Train {
    dataset: &train !obj:pylearn2.datasets.transformer_dataset.TransformerDataset {
        raw: !obj:pylearn2.datasets.mnist.MNIST {
            which_set: 'train',
            start: 0,
            stop: %(train_stop)i
        },
        transformer: !obj:pylearn2.blocks.StackedBlocks {
            layers: [!pkl: "dae_l1.pkl", !pkl: "dae_l2.pkl"]
        }
    },
    model: !obj:pylearn2.models.autoencoder.DenoisingAutoencoder {
        nvis : %(nvis)i,
        nhid : %(nhid)i,
        irange : 0.05,
        corruptor: !obj:pylearn2.corruption.BinomialCorruptor {
            corruption_level: .3,
        },
        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 : %(batch_size)i,
        monitoring_batches : %(monitoring_batches)i,
        monitoring_dataset : *train,
        cost : !obj:pylearn2.costs.autoencoder.MeanSquaredReconstructionError {},
        termination_criterion : !obj:pylearn2.termination_criteria.EpochCounter {
            max_epochs: %(max_epochs)i,
        },
    },
    save_path: "%(save_path)s/dae_l3.pkl",
    save_freq: 1
}

Definieren Sie abschließend ein Modell, in dem jede Ebene zur Feinabstimmung verkettet ist. Die Ausgabeschicht enthält 10 Einheiten, und jeder Wert kann als Wahrscheinlichkeit für das Zeichen von 0 bis 9 angesehen werden.

`dae_mlp.yaml`


!obj:pylearn2.train.Train {
    dataset: &train !obj:pylearn2.datasets.mnist.MNIST {
        which_set: 'train',
        start: 0,
        stop: %(train_stop)i
    },
    model: !obj:pylearn2.models.mlp.MLP {
        batch_size: %(batch_size)i,
        layers: [
                 !obj:pylearn2.models.mlp.PretrainedLayer {
                     layer_name: 'h1',
                     layer_content: !pkl: "%(save_path)s/dae_l1.pkl"
                 },
                 !obj:pylearn2.models.mlp.PretrainedLayer {
                     layer_name: 'h2',
                     layer_content: !pkl: "%(save_path)s/dae_l2.pkl"
                 },
                 !obj:pylearn2.models.mlp.PretrainedLayer {
                     layer_name: 'h3',
                     layer_content: !pkl: "%(save_path)s/dae_l3.pkl"
                 },
                 !obj:pylearn2.models.mlp.Softmax {
                     max_col_norm: 1.9365,
                     layer_name: 'y',
                     n_classes: 10,
                     irange: .005
                 }
                ],
        nvis: 784
    },
    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' : !obj:pylearn2.datasets.mnist.MNIST {
                              which_set: 'train',
                              start: 0,
                              stop: %(valid_stop)i
                          },
            },
        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: %(max_epochs)i
                }
            ]
        },
        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: "%(save_path)s/dae_mlp.pkl",
    save_freq: 1
}

Lerne

Ändern und verwenden Sie das im Tutorial stacked_autoencoders enthaltene Lernskript. Die folgenden Änderungen wurden vorgenommen.

Im Tutorial wurde die verborgene Ebene von 2 Ebenen auf 3 Ebenen geändert
Es wurde behoben, dass die Anzahl der Trainingsdaten (train_stop) und die maximale Anzahl der Trainings (max_epochs) gering sind, wahrscheinlich um die Trainingszeit zu verkürzen. Alle 60.000 Trainingsdaten wurden verwendet und die maximale Anzahl von Trainingseinheiten betrug 100.

Bei der Ausführung werden die Dateien ausgegeben, die den einzelnen Modellen dae_l1.pkl, dae_l2.pkl, dae_l3.pkl, dae_mlp.pkl entsprechen. In Bezug auf die Ausführungszeit dauerte es in meiner Umgebung (Core i7-3770) ungefähr 20 Minuten.

`test_dae.py`


import os

from pylearn2.testing import skip
from pylearn2.testing import no_debug_mode
from pylearn2.config import yaml_parse


@no_debug_mode
def train_yaml(yaml_file):

    train = yaml_parse.load(yaml_file)
    train.main_loop()


def train_layer1(yaml_file_path, save_path):

    yaml = open("{0}/dae_l1.yaml".format(yaml_file_path), 'r').read()
    hyper_params = {'train_stop': 60000,
                    'batch_size': 100,
                    'monitoring_batches': 1,
                    'nhid': 100,
                    'max_epochs': 100,
                    'save_path': save_path}
    yaml = yaml % (hyper_params)
    train_yaml(yaml)


def train_layer2(yaml_file_path, save_path):

    yaml = open("{0}/dae_l2.yaml".format(yaml_file_path), 'r').read()
    hyper_params = {'train_stop': 60000,
                    'batch_size': 100,
                    'monitoring_batches': 1,
                    'nvis': 100,
                    'nhid': 100,
                    'max_epochs': 100,
                    'save_path': save_path}
    yaml = yaml % (hyper_params)
    train_yaml(yaml)


def train_layer3(yaml_file_path, save_path):

    yaml = open("{0}/dae_l3.yaml".format(yaml_file_path), 'r').read()
    hyper_params = {'train_stop': 60000,
                    'batch_size': 100,
                    'monitoring_batches': 1,
                    'nvis': 100,
                    'nhid': 100,
                    'max_epochs': 100,
                    'save_path': save_path}
    yaml = yaml % (hyper_params)
    train_yaml(yaml)


def train_mlp(yaml_file_path, save_path):

    yaml = open("{0}/dae_mlp.yaml".format(yaml_file_path), 'r').read()
    hyper_params = {'train_stop': 60000,
                    'valid_stop': 60000,
                    'batch_size': 100,
                    'max_epochs': 100,
                    'save_path': save_path}
    yaml = yaml % (hyper_params)
    train_yaml(yaml)


def test_sda():

    skip.skip_if_no_data()

    yaml_file_path = '.';
    save_path = '.'

    train_layer1(yaml_file_path, save_path)
    train_layer2(yaml_file_path, save_path)
    train_layer3(yaml_file_path, save_path)
    train_mlp(yaml_file_path, save_path)

if __name__ == '__main__':
    test_sda()

Führen Sie die Zeichenerkennung anhand von Testdaten durch

Die Zeichenerkennung wird unter Verwendung von Testdaten durchgeführt und die Erkennungsrate wird erhalten. Ich erhalte die Testdaten mit pylearn2.datasets.mnist.MNIST (which_set = 'test') und verwende das fprop des Modells, um den Wert der Ausgabeschicht zu ermitteln. Das Zeichen, das der Ausgabeeinheit mit dem größten Wert entspricht, wird als vorhergesagter Wert verwendet. In meiner Umgebung waren 9814 von 10000 korrekt.

`test_result.py`


import numpy as np
import pickle
import theano
import pylearn2.datasets.mnist as mnist


def simulate(inputs, model):
    return model.fprop(theano.shared(inputs)).eval()

def countCorrectResults(outputs, labels):
    correct = 0;
    for output, label in zip(outputs, labels):
        if np.argmax(output) == label:
            correct += 1
    return correct
 
def score(dataset, model):
    outputs = simulate(dataset.X, model)
    correct = countCorrectResults(outputs, dataset.y)

    return {
        'correct': correct,
        'total': len(dataset.X)
    }

model = pickle.load(open('dae_mlp.pkl'))
test_data = mnist.MNIST(which_set='test')
print '%(correct)d / %(total)d' % score(test_data, model)

Verweise

Ich habe auf die folgende Seite verwiesen. http://tanopy.blog79.fc2.com/blog-entry-118.html http://www.slideshare.net/yurieoka37/ss-28152060

[PYTHON] Führen Sie die handschriftliche Zeichenerkennung mit Pylearn 2 durch

Daten herunterladen

Überprüfen Sie die Daten

dataset.yaml

show_samples.py

Definieren Sie ein Modell

dae_l1.yaml

dae_l2.yaml

dae_mlp.yaml