CNTK - Neuronale Netzregression
Das Kapitel wird Ihnen helfen, die Regression des neuronalen Netzwerks in Bezug auf CNTK zu verstehen.
Einführung
Da wir wissen, dass wir eine Regression verwenden, um einen numerischen Wert aus einer oder mehreren Prädiktorvariablen vorherzusagen. Nehmen wir ein Beispiel für die Vorhersage des Medianwerts eines Hauses in einer der 100 Städte. Zu diesem Zweck verfügen wir über Daten, die Folgendes umfassen:
Eine Kriminalstatistik für jede Stadt.
Das Alter der Häuser in jeder Stadt.
Ein Maß für die Entfernung von jeder Stadt zu einer erstklassigen Lage.
Das Schüler-Lehrer-Verhältnis in jeder Stadt.
Eine rassendemografische Statistik für jede Stadt.
Der mittlere Hauswert in jeder Stadt.
Basierend auf diesen fünf Prädiktorvariablen möchten wir den mittleren Hauswert vorhersagen. Und dafür können wir ein lineares Regressionsmodell nach dem Vorbild von− erstellen
Y = a0+a1(crime)+a2(house-age)+(a3)(distance)+(a4)(ratio)+(a5)(racial)In der obigen Gleichung -
Y ist ein vorhergesagter Medianwert
a0 ist eine Konstante und
a1 bis a5 Alle sind Konstanten, die den fünf oben diskutierten Prädiktoren zugeordnet sind.
Wir haben auch einen alternativen Ansatz zur Verwendung eines neuronalen Netzwerks. Es wird ein genaueres Vorhersagemodell erstellt.
Hier erstellen wir mithilfe von CNTK ein Regressionsmodell für neuronale Netze.
Datensatz wird geladen
Um die Regression des neuronalen Netzwerks mithilfe von CNTK zu implementieren, verwenden wir den Hauswertdatensatz des Gebiets Boston. Der Datensatz kann aus dem UCI Machine Learning Repository heruntergeladen werden, das unter verfügbar isthttps://archive.ics.uci.edu/ml/machine-learning-databases/housing/. Dieser Datensatz enthält insgesamt 14 Variablen und 506 Instanzen.
Für unser Implementierungsprogramm werden wir jedoch sechs der 14 Variablen und 100 Instanzen verwenden. Von 6 5 als Prädiktoren und einer als Vorhersagewert. Von 100 Instanzen werden wir 80 für Schulungen und 20 für Testzwecke verwenden. Der Wert, den wir vorhersagen möchten, ist der mittlere Hauspreis in einer Stadt. Sehen wir uns die fünf Prädiktoren an, die wir verwenden werden -
Crime per capita in the town - Wir würden erwarten, dass diesem Prädiktor kleinere Werte zugeordnet werden.
Proportion of owner - besetzte Einheiten, die vor 1940 gebaut wurden - Wir würden erwarten, dass diesem Prädiktor kleinere Werte zugeordnet werden, da ein größerer Wert ein älteres Haus bedeutet.
Weighed distance of the town to five Boston employment centers.
Area school pupil-to-teacher ratio.
An indirect metric of the proportion of black residents in the town.
Trainings- und Testdateien vorbereiten
Wie zuvor müssen wir zuerst die Rohdaten in das CNTK-Format konvertieren. Wir werden die ersten 80 Datenelemente für Schulungszwecke verwenden, daher lautet das durch Tabulatoren getrennte CNTK-Format wie folgt:
|predictors 1.612820 96.90 3.76 21.00 248.31 |medval 13.50
|predictors 0.064170 68.20 3.36 19.20 396.90 |medval 18.90
|predictors 0.097440 61.40 3.38 19.20 377.56 |medval 20.00
. . .Die nächsten 20 Elemente, die ebenfalls in das CNTK-Format konvertiert wurden, werden zu Testzwecken verwendet.
Regressionsmodell konstruieren
Zuerst müssen wir die Datendateien im CNTK-Format verarbeiten und dafür werden wir die genannte Hilfsfunktion verwenden create_reader wie folgt -
def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='predictors', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='medval', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_srcAls Nächstes müssen wir eine Hilfsfunktion erstellen, die ein CNTK-Mini-Batch-Objekt akzeptiert und eine benutzerdefinierte Genauigkeitsmetrik berechnet.
def mb_accuracy(mb, x_var, y_var, model, delta):
num_correct = 0
num_wrong = 0
x_mat = mb[x_var].asarray()
y_mat = mb[y_var].asarray()
for i in range(mb[x_var].shape[0]):
v = model.eval(x_mat[i])
y = y_mat[i]
if np.abs(v[0,0] – y[0,0]) < delta:
num_correct += 1
else:
num_wrong += 1
return (num_correct * 100.0)/(num_correct + num_wrong)Jetzt müssen wir die Architekturargumente für unser NN festlegen und auch den Speicherort der Datendateien angeben. Dies kann mit Hilfe des folgenden Python-Codes erfolgen -
def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 5
hidden_dim = 20
output_dim = 1
train_file = ".\\...\\" #provide the name of the training file(80 data items)
test_file = ".\\...\\" #provide the name of the test file(20 data items)Mit Hilfe der folgenden Codezeile erstellt unser Programm nun das untrainierte NN -
X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
model = C.ops.alias(oLayer)Nachdem wir das duale untrainierte Modell erstellt haben, müssen wir ein Learner-Algorithmusobjekt einrichten. Wir werden SGD-Lernende verwenden undsquared_error Verlustfunktion -
tr_loss = C.squared_error(model, Y)
max_iter = 3000
batch_size = 5
base_learn_rate = 0.02
sch=C.learning_parameter_schedule([base_learn_rate, base_learn_rate/2], minibatch_size=batch_size, epoch_size=int((max_iter*batch_size)/2))
learner = C.sgd(model.parameters, sch)
trainer = C.Trainer(model, (tr_loss), [learner])Sobald wir mit dem Lernalgorithmusobjekt fertig sind, müssen wir eine Lesefunktion erstellen, um die Trainingsdaten zu lesen.
rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }Jetzt ist es Zeit, unser NN-Modell zu trainieren -
for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=boston_input_map) trainer.train_minibatch(curr_batch)
if i % int(max_iter/10) == 0:
mcee = trainer.previous_minibatch_loss_average
acc = mb_accuracy(curr_batch, X, Y, model, delta=3.00)
print("batch %4d: mean squared error = %8.4f, accuracy = %5.2f%% " \ % (i, mcee, acc))Nachdem wir mit dem Training fertig sind, lassen Sie uns das Modell anhand von Testdaten bewerten.
print("\nEvaluating test data \n")
rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=boston_input_map)
acc = mb_accuracy(all_test, X, Y, model, delta=3.00)
print("Prediction accuracy = %0.2f%%" % acc)Nachdem wir die Genauigkeit unseres trainierten NN-Modells bewertet haben, werden wir es verwenden, um eine Vorhersage für unsichtbare Daten zu treffen -
np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])Komplettes Regressionsmodell
import numpy as np
import cntk as C
def create_reader(path, input_dim, output_dim, rnd_order, sweeps):
x_strm = C.io.StreamDef(field='predictors', shape=input_dim, is_sparse=False)
y_strm = C.io.StreamDef(field='medval', shape=output_dim, is_sparse=False)
streams = C.io.StreamDefs(x_src=x_strm, y_src=y_strm)
deserial = C.io.CTFDeserializer(path, streams)
mb_src = C.io.MinibatchSource(deserial, randomize=rnd_order, max_sweeps=sweeps)
return mb_src
def mb_accuracy(mb, x_var, y_var, model, delta):
num_correct = 0
num_wrong = 0
x_mat = mb[x_var].asarray()
y_mat = mb[y_var].asarray()
for i in range(mb[x_var].shape[0]):
v = model.eval(x_mat[i])
y = y_mat[i]
if np.abs(v[0,0] – y[0,0]) < delta:
num_correct += 1
else:
num_wrong += 1
return (num_correct * 100.0)/(num_correct + num_wrong)
def main():
print("Using CNTK version = " + str(C.__version__) + "\n")
input_dim = 5
hidden_dim = 20
output_dim = 1
train_file = ".\\...\\" #provide the name of the training file(80 data items)
test_file = ".\\...\\" #provide the name of the test file(20 data items)
X = C.ops.input_variable(input_dim, np.float32)
Y = C.ops.input_variable(output_dim, np.float32)
with C.layers.default_options(init=C.initializer.uniform(scale=0.01, seed=1)):
hLayer = C.layers.Dense(hidden_dim, activation=C.ops.tanh, name='hidLayer')(X)
oLayer = C.layers.Dense(output_dim, activation=None, name='outLayer')(hLayer)
model = C.ops.alias(oLayer)
tr_loss = C.squared_error(model, Y)
max_iter = 3000
batch_size = 5
base_learn_rate = 0.02
sch = C.learning_parameter_schedule([base_learn_rate, base_learn_rate/2], minibatch_size=batch_size, epoch_size=int((max_iter*batch_size)/2))
learner = C.sgd(model.parameters, sch)
trainer = C.Trainer(model, (tr_loss), [learner])
rdr = create_reader(train_file, input_dim, output_dim, rnd_order=True, sweeps=C.io.INFINITELY_REPEAT)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
for i in range(0, max_iter):
curr_batch = rdr.next_minibatch(batch_size, input_map=boston_input_map) trainer.train_minibatch(curr_batch)
if i % int(max_iter/10) == 0:
mcee = trainer.previous_minibatch_loss_average
acc = mb_accuracy(curr_batch, X, Y, model, delta=3.00)
print("batch %4d: mean squared error = %8.4f, accuracy = %5.2f%% " \ % (i, mcee, acc))
print("\nEvaluating test data \n")
rdr = create_reader(test_file, input_dim, output_dim, rnd_order=False, sweeps=1)
boston_input_map = { X : rdr.streams.x_src, Y : rdr.streams.y_src }
num_test = 20
all_test = rdr.next_minibatch(num_test, input_map=boston_input_map)
acc = mb_accuracy(all_test, X, Y, model, delta=3.00)
print("Prediction accuracy = %0.2f%%" % acc)
np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])
if __name__== ”__main__”:
main()Ausgabe
Using CNTK version = 2.7
batch 0: mean squared error = 385.6727, accuracy = 0.00%
batch 300: mean squared error = 41.6229, accuracy = 20.00%
batch 600: mean squared error = 28.7667, accuracy = 40.00%
batch 900: mean squared error = 48.6435, accuracy = 40.00%
batch 1200: mean squared error = 77.9562, accuracy = 80.00%
batch 1500: mean squared error = 7.8342, accuracy = 60.00%
batch 1800: mean squared error = 47.7062, accuracy = 60.00%
batch 2100: mean squared error = 40.5068, accuracy = 40.00%
batch 2400: mean squared error = 46.5023, accuracy = 40.00%
batch 2700: mean squared error = 15.6235, accuracy = 60.00%
Evaluating test data
Prediction accuracy = 64.00%
Predicting median home value for feature/predictor values:
[0.09 50. 4.5 17. 350.]
Predicted value is:
$21.02(x1000)Speichern des trainierten Modells
Dieser Boston Home-Wertdatensatz enthält nur 506 Datenelemente (von denen wir nur 100 verklagt haben). Daher würde das Trainieren des NN-Regressormodells nur wenige Sekunden dauern, aber das Training eines großen Datensatzes mit hundert oder tausend Datenelementen kann Stunden oder sogar Tage dauern.
Wir können unser Modell speichern, damit wir es nicht von Grund auf neu aufbewahren müssen. Mit Hilfe des folgenden Python-Codes können wir unser trainiertes NN speichern -
nn_regressor = “.\\neuralregressor.model” #provide the name of the file
model.save(nn_regressor, format=C.ModelFormat.CNTKv2)Im Folgenden sind die oben verwendeten Argumente der Funktion save () aufgeführt:
Dateiname ist das erste Argument von save()Funktion. Es kann auch zusammen mit dem Dateipfad geschrieben werden.
Ein weiterer Parameter ist der format Parameter, der einen Standardwert hat C.ModelFormat.CNTKv2.
Laden des trainierten Modells
Sobald Sie das trainierte Modell gespeichert haben, ist es sehr einfach, dieses Modell zu laden. Wir müssen nur die Funktion load () verwenden. Lassen Sie uns dies im folgenden Beispiel überprüfen -
import numpy as np
import cntk as C
model = C.ops.functions.Function.load(“.\\neuralregressor.model”)
np.set_printoptions(precision = 2, suppress=True)
unknown = np.array([[0.09, 50.00, 4.5, 17.00, 350.00], dtype=np.float32)
print("\nPredicting area median home value for feature/predictor values: ")
print(unknown[0])
pred_prob = model.eval({X: unknown)
print("\nPredicted value is: ")
print(“$%0.2f (x1000)” %pred_value[0,0])Der Vorteil des gespeicherten Modells besteht darin, dass ein gespeichertes Modell nach dem Laden genau so verwendet werden kann, als ob das Modell gerade trainiert worden wäre.