Theanos Tutorial (http://deeplearning.net/tutorial/contents.html) Basierend darauf habe ich eine logistische Regression mit Kaggles MNIST-Daten implementiert.
from __future__ import print_function
__docformat__ = 'restructedtext en'
import six.moves.cPickle as pickle
import timeit
import numpy
import theano
import theano.tensor as T
import numpy as np
rng = numpy.random.RandomState(8000)
#Definition von gemeinsam genutzten Variablen
#Die durch diesen Ausdruck erstellten Daten sind
#-------------------------------------------------------------------------
#Logistische Regressionsklasse
#-------------------------------------------------------------------------
class LogisticRegression(object):
"""Multi-class Logistic Regression Clasｓ
"""
def __init__(self, input, n_in, n_out):
#MODEL
#Gemeinsame Variablendarstellung
#Über W.
self.W = theano.shared(
value=numpy.zeros(
(n_in, n_out),
dtype=theano.config.floatX
),
name='W',
borrow=True
)
#Ausleihen bestimmt, ob die im Python-Bereich definierte Datenentität auch von gemeinsam genutzten Variablen gemeinsam genutzt wird.
#Über b
self.b = theano.shared(
value=numpy.zeros(
(n_out,),
dtype=theano.config.floatX
),
name='b',
borrow=True
)
#Berechnung der Softmax-Funktion (Wahrscheinlichkeit der Zuordnung zur Klasse berechnen)
#ｐ(y＝i|x,W,b)
self.p_y_given_x = T.nnet.softmax(T.dot(input, self.W) + self.b)
#Nehmen Sie argmax und geben Sie den vorhergesagten Wert aus
#ypred
self.y_pred = T.argmax(self.p_y_given_x, axis=1)
#.In paramsn gespeichert
self.params = [self.W, self.b]
#.In Eingabe speichern
self.input = input
#Verlustfunktion
def negative_log_likelihood(self, y):
#Definition der Verlustfunktion
#self.p_y_given_x ist die Softmax-Funktion (Ausgabe yn)
#T.arange(y.shape[0])Ist die Zeile und Spalte von Numpy[]
#-Ln(p(t｜w)).PRML4.Typ 90
return -T.mean(T.log(self.p_y_given_x)[T.arange(y.shape[0]), y])
#Fehlerrate
def errors(self, y):
#Überprüfen der Abmessungen des Ausgangs
if y.ndim != self.y_pred.ndim:
raise TypeError(
'y should have the same shape as self.y_pred',
('y', y.type, 'y_pred', self.y_pred.type)
)
#Überprüfen Sie, ob der Datentyp korrekt ist
if y.dtype.startswith('int'):
#neq Ausgaben ungleich Ausgabe Antwort ist korrekt und korrekte Wahrscheinlichkeit
#Erstes Argument: Argument mit dem Bild mit der maximalen Ausgabewahrscheinlichkeit
#Zweites Argument: Richtige Bezeichnung
return T.mean(T.neq(self.y_pred, y))
else:
raise NotImplementedError()
#Mini-Batch-stochastische Gradientenabstiegsmethode
def sgd_optimization_mnist(learning_rate=0.10, n_epochs=100,
dataset='mnist.pkl.gz',
batch_size=500):
dtype = np.float32
data = np.loadtxt("../input/train.csv", dtype=dtype,
delimiter=',', skiprows=1)
test_data = np.loadtxt("../input/test.csv", dtype=dtype,
delimiter=',', skiprows=1)
test_datasets=[test_data]
print (data.shape)
labels = data[:,0]
data = data[:, 1:]
index = T.lscalar() #Minibatch-Index
NUM_TRAIN = len(data)
NUM_TEST = len(test_data)
if NUM_TRAIN % batch_size != 0:
whole = (NUM_TRAIN // batch_size) * batch_size
data = data[:whole]
NUM_TRAIN = len(data)
#zufällige Sortierung
indices = rng.permutation(NUM_TRAIN)
data, labels = data[indices, :], labels[indices]
# batch_Größe ist 500, (480, 20)Trainieren Sie mit 96% des Datensatzes und validieren Sie mit dem Rest
is_train = numpy.array( ([0]* (batch_size - 20) + [1] * 20) * (NUM_TRAIN // batch_size))
test_indices = rng.permutation(NUM_TEST)
test_data, test_labels = test_data[test_indices, :], labels[test_indices]
is_test = numpy.array( ([0]* (batch_size - 20) + [1] * 20) * (NUM_TEST // batch_size))
# trai_set,valid_set,test_Vorbereitung des Sets
train_set_x, train_set_y = numpy.array(data[is_train==0]), labels[is_train==0]
valid_set_x, valid_set_y = numpy.array(data[is_train==1]), labels[is_train==1]
test_set_x,test_set_y = numpy.array(data[is_test==0]), labels[is_test==0]
#Minibatch-Berechnung
n_train_batches = len(train_set_y) // batch_size
n_valid_batches = len(valid_set_y) // batch_size
n_test_batches = len(test_set_y) // batch_size
##############
#Ein Modell bauen#
##############
print('... building the model')
#langer Skalar
index = T.lscalar()
#Matrixtyp
x = T.matrix('x')
#int Typ Vektor
y = T.ivector('y')
#Aufbau einer logistischen Regressionsklasse
#MNIST-Daten sind 28X28
classifier = LogisticRegression(input=x, n_in=28 * 28, n_out=10)
#Kostenfunktion ist negative Log-Wahrscheinlichkeit
cost = classifier.negative_log_likelihood(y)
#Mini Batch Typ Theano.Mit Funktion zusammenfassen
train_set_x = theano.shared(numpy.asarray(train_set_x, dtype=theano.config.floatX))
train_set_y = T.cast(theano.shared(numpy.asarray(train_set_y, dtype=theano.config.floatX)), 'int32')
test_set_x = theano.shared(numpy.asarray(test_set_x, dtype=theano.config.floatX))
test_set_y = T.cast(theano.shared(numpy.asarray(test_set_y, dtype=theano.config.floatX)), 'int32')
valid_set_x = theano.shared(numpy.asarray(valid_set_x, dtype=theano.config.floatX))
valid_set_y = T.cast(theano.shared(numpy.asarray(valid_set_y, dtype=theano.config.floatX)), 'int32')
#Modell validieren
validate_model = theano.function(
inputs=[index],
outputs=classifier.errors(y),
givens={
x: valid_set_x[index * batch_size: (index + 1) * batch_size],
y: valid_set_y[index * batch_size: (index + 1) * batch_size]
}
)
#Testmodell
test_model = theano.function(
inputs=[index],
outputs=classifier.errors(y),
givens={
x: valid_set_x[index * batch_size:(index + 1) * batch_size],
y: valid_set_y[index * batch_size:(index + 1) * batch_size]
}
)
#Kosten differenzieren nach W.
g_W = T.grad(cost=cost, wrt=classifier.W)
#Kosten differenzieren durch b
g_b = T.grad(cost=cost, wrt=classifier.b)
#Kostenfunktion ist negative Log-Wahrscheinlichkeit
#Parameter (W.,b) Aktualisieren
updates = [(classifier.W, classifier.W - learning_rate * g_W),
(classifier.b, classifier.b - learning_rate * g_b)]
#Zugmodell
#In Updates definierte Parameter (W.,b) Aktualisieren
train_model = theano.function(
inputs=[index],
outputs=cost,
updates=updates,
givens={
x: train_set_x[index * batch_size: (index + 1) * batch_size],
y: train_set_y[index * batch_size: (index + 1) * batch_size]
}
)
#################
#Modelltraining#
#################
print('... training the model')
#Maximale Anzahl von LOOPs
patience = 50000
#Wenn es nicht mehr als 2 erhöht
patience_increase = 5
#Obergrenze der Noten
improvement_threshold = 0.995
#Häufigkeit der Begegnung mit Geduld. In diesem Fall überprüfen Sie mit jeder Epoche
validation_frequency = min(n_train_batches, patience // 2)
best_validation_loss = numpy.inf
test_score = 0.
start_time = timeit.default_timer()
#Der Beginn von LOOP
done_looping = False
epoch = 0
minibatch_index = 1
while (epoch < n_epochs) and (not done_looping):
epoch = epoch + 1
for minibatch_index in range(n_train_batches):
minibatch_avg_cost = train_model(minibatch_index)
#Berechnung der Iteration
iter = (epoch - 1) * n_train_batches + minibatch_index
if (iter + 1) % validation_frequency == 0:
# zero-Ein durch Validierung berechneter Verlust
validation_losses = [validate_model(i)
for i in range(n_valid_batches)]
this_validation_loss = numpy.mean(validation_losses)
print(
'epoch %i, minibatch %i/%i, validation error %f %%' %
(
epoch,
minibatch_index + 1,
n_train_batches,
this_validation_loss * 100.
)
)
#Wenn der Validierungsverlust am geringsten ist
if this_validation_loss < best_validation_loss:
if this_validation_loss < best_validation_loss * \
improvement_threshold:
patience = max(patience, iter * patience_increase)
best_validation_loss = this_validation_loss
#Test mit Testset
test_losses = [test_model(i)
for it in range(len(test_datasets))]
test_score = numpy.mean(test_losses)
print(
(
' epoch %i, minibatch %i/%i, test error of'
' best model %f %%'
) %
(
epoch,
minibatch_index + 1,
n_train_batches,
test_score * 100.
)
)
#Speichern Sie das beste Modell
with open('best_model.pkl', 'wb') as f:
pickle.dump(classifier, f)
if patience <= iter:
done_looping = True
break
end_time = timeit.default_timer()
print(
(
'Optimization complete with best validation score of %f %%,'
'with test performance %f %%'
)
% (best_validation_loss * 100., test_score * 100.)
)
print('The code run for %d epochs, with %f epochs/sec' % (
epoch, 1. * epoch / (end_time - start_time)))
def predict():
"""
An example of how to load a trained model and use it
to predict labels.
"""
#Rufen Sie das trainierte Modell an
classifier = pickle.load(open('best_model.pkl'))
#Modell vorhersagen
predict_model = theano.function(
inputs=[classifier.input],
outputs=classifier.y_pred)
#Rufen Sie das Testset auf
test_data = np.loadtxt("../input/test.csv", dtype=dtype,
delimiter=',', skiprows=1)
#vorhersagen
predicted_values = predict_model(test_data)
print("Predicted values for the first 10 examples in test set:")
print(predicted_values)
np.savetxt('Submit_TheanoLR3.csv', np.c_[range(1, len(test_data) + 1), predicted_values], delimiter=',', comments = '', header = 'ImageId,Label', fmt='%d')
if __name__ == '__main__':
sgd_optimization_mnist()
Das Ergebnis ist 0,90757. Es war 0,90900 in Scikit-Learn, und es scheint so.
Recommended Posts