Maschinelles Lernen wird heutzutage in verschiedenen Diensten eingesetzt. Unter diesen zieht die Methode Deep Learning als Hochleistungsmethode Aufmerksamkeit auf sich. In diesem Artikel werde ich darüber schreiben, wie Deep Learning mithilfe einer maschinellen Lernbibliothek von LISA-Lab namens pylearn2 ausgeführt wird. Das Ziel ist eine Bilddatei.
Es scheint, dass es viele Artikel gibt, in denen das Tutorial von pyleran2 ausgeführt wird, aber es scheint, dass fast keine Informationen geschrieben wurden, um die von mir erstellten Daten zu lernen. Daher ist "Deep Learning" oder "pylearn2" erstaunlich. Ich verstehe, aber es ist für Leute, die nicht wissen, wie man es benutzt. Ich werde die Installations-, Verwendungs- und Tutorial-Teile von pylearn2 weglassen.
Ich denke auch, dass es verschiedene Methoden gibt, aber hier ist ein Beispiel.
Der Gesamtfluss ist wie folgt. Ich werde jedes im Detail erklären.
Dieses Mal wird das Arbeitsverzeichnis an der folgenden Stelle unter dem Verzeichnis von pylearn2 erstellt. Ich werde erklären, dass alle Dateien, die dieses Mal verarbeitet werden, im Grunde direkt unter diesem Verzeichnis abgelegt werden.
pylearn2/pylearn2/script/tutorials/sample
Außerdem werde ich das Skript zum Lesen und Testen des CSV-Datensatzes ausleihen, wie er in pylearn2 in der Praxis veröffentlicht ist. Sie können es von der GitHub-Seite mit einem Link am Ende der Seite herunterladen.
Geben Sie nach dem Herunterladen "adult_dataset.py" in das folgende Verzeichnis ein.
pylearn2/pylearn2/datasets
Konvertieren Sie zunächst die Bilddatei in eine CSV-Datei. Alle zu trainierenden Bilddaten werden als eine CSV-Daten ausgegeben. Wie im folgenden Beispiel gezeigt, besteht die CSV-Regel darin, jedes Bild als eine Zeile, den Anfang als zugehörige Klasse und die nachfolgenden Teile als Pixeldaten mit einem Komma "," zu trennen. Natürlich können Sie es später ändern, auch wenn es kein Komma ist, aber hier werden wir es mit einem Komma erklären.
train.csv
Klasse,Pixeldaten 1,Pixeldaten 2,Pixeldaten 3,...
Klasse,Pixeldaten 1,Pixeldaten 2,Pixeldaten 3,...
Klasse,Pixeldaten 1,Pixeldaten 2,Pixeldaten 3,...
...
Es spielt keine Rolle, wie Sie es machen, aber ich habe vorerst OpenCV verwendet. Als Beispiel sieht es so aus. Der Einfachheit halber haben wir 200 Bilder aufgenommen, die nacheinander benannt wurden, wobei die ersten 100 Klasse 0 und die letzten 100 Klasse 1 sind. Diesmal handelt es sich um eine Zwei-Klassen-Klassifizierung, die Sie jedoch weiter erhöhen können. Erhöhen Sie sie daher gegebenenfalls mit einer Ganzzahl. Ändern Sie diesen Bereich nach Bedarf.
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");
}
}
Eine solche Datei wird erstellt (numerische Werte sind Beispiele). Insgesamt sollten 200 Zeilen vorhanden sein. Legen Sie die erstellte Datei im Arbeitsverzeichnis ab.
0,13,15,18,41,11,...
0,19,40,50,31,23,...
...
...
1,135,244,210,15,150,...
1,45,167,84,210,100,...
Konvertieren Sie die erstellte CSV in eine pkl-Datei, damit sie von Python problemlos verarbeitet werden kann. Die Quelle sieht so aus.
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'))
Nachdem die Daten fertig sind, trainieren wir sie tatsächlich. Das diesmal zu erstellende Netzwerk ist ein 3-Schicht-Netzwerk mit 2 Schichten AutoEncoder und einer Softmax-Regressionsschicht als Diskriminator.
Das Yaml jeder Schicht sieht so aus. Da die Zahlen, die beliebig eingestellt werden können, grob sind, ändern Sie jeden Parameter nach Bedarf. Was wichtig ist, ist
--nvis: Anzahl der Eingabeeinheiten. Die erste Ebene muss die gleiche Anzahl von Pixeln wie das Bild haben, und die zweite Ebene muss die gleiche Anzahl von Einheiten (nhid) haben wie die ausgeblendete Ebene der ersten Ebene. --n_Classes: Anzahl der Ausgabeklassen. Geben Sie die Anzahl der Klassen an, die Sie klassifizieren möchten. In diesem Beispiel 2.
Wenn dies nicht richtig eingestellt ist, wird es zunächst nicht gelernt. Wenn es also nicht funktioniert, möchten Sie möglicherweise überprüfen, ob Sie hier einen Fehler gemacht haben oder ob Sie beim Erstellen der CSV-Datei einen Fehler gemacht haben. Hmm.
Die Ergebnisse vor dem Training für die erste und zweite Schicht werden an DAE_l1.pkl und DAE_l2.pkl ausgegeben.
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
}
Wenn yaml fertig ist, führen Sie das folgende Skript aus, um es zu trainieren.
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')
Bei der Ausführung wird eine Datei mit dem Namen "mlp.pkl" generiert. Da dies das Lernergebnis ist, werden wir es als nächstes tatsächlich verwenden, um einen Identifikationstest durchzuführen.
Die Methode zum Erstellen von Testdaten entspricht den Trainingsdaten, und das Bild wird in eine CSV-Datei-> pkl konvertiert. Hier ist es "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'))
Sie können ein Skript wie das folgende ausführen, um zu drucken, wie viele der Testdaten als die richtige Klasse identifiziert wurden.
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)
Wie oben erwähnt, denke ich, dass Sie alles vom Lernen bis zum Testen mit Ihren eigenen Daten tun können. Ich habe es unterwegs bemerkt, aber es scheint, dass pylearn2 auch ein Leseskript (pylearn2 / pylearn2 / datasets / csv_dataset.py) enthält, das CSV-Datasets unterstützt. Sie können es also verwenden.
Implementierung Deep Learning pylearn2 dev Documentation pylearn2 in practice
Recommended Posts