tensorflow
Einfache lineare Regressionsstruktur in TensorFlow mit Python
Suche…
Einführung
Ein in der traditionellen Statistik weit verbreitetes Modell ist das lineare Regressionsmodell. In diesem Artikel besteht das Ziel darin, die schrittweise Implementierung dieser Art von Modellen zu verfolgen. Wir werden eine einfache lineare Regressionsstruktur darstellen.
Für unsere Studie analysieren wir das Alter der Kinder auf der X- Achse und die Höhe der Kinder auf der Y- Achse. Wir werden versuchen, die Größe der Kinder anhand ihres Alters vorherzusagen und eine einfache lineare Regression anzuwenden. [In TF finden Sie das beste W und b]
Parameter
| Parameter | Beschreibung |
|---|---|
| train_X | np Array mit x-Dimension der Informationen |
| train_Y | np Array mit y-Dimension der Informationen |
Bemerkungen
Ich habe TensorBoard sintaxis verwendet, um das Verhalten einiger Teile des Modells, Kosten, Zug und Aktivierungselemente zu verfolgen.
with tf.name_scope("") as scope:
Verwendete Importe:
import numpy as np
import tensorflow as tf
Art der Anwendung und Sprache:
Ich habe einen traditionellen, in Python entwickelten App-Typ für die Konsolenimplementierung verwendet, um das Beispiel darzustellen.
Version von TensorFlow verwendet:
1.0.1
Konzeptionelles akademisches Beispiel / Referenz hieraus extrahiert:
Einfache Code-Struktur für die Regressionsfunktion
Funktionsdefinition:
def run_training(train_X, train_Y):
Eingangsvariablen:
X = tf.placeholder(tf.float32, [m, n])
Y = tf.placeholder(tf.float32, [m, 1])
Darstellung von Gewicht und Vorsatz
W = tf.Variable(tf.zeros([n, 1], dtype=np.float32), name="weight")
b = tf.Variable(tf.zeros([1], dtype=np.float32), name="bias")
Lineal modell:
with tf.name_scope("linear_Wx_b") as scope:
activation = tf.add(tf.matmul(X, W), b)
Kosten:
with tf.name_scope("cost") as scope:
cost = tf.reduce_sum(tf.square(activation - Y)) / (2 * m)
tf.summary.scalar("cost", cost)
Ausbildung:
with tf.name_scope("train") as scope:
optimizer = tf.train.GradientDescentOptimizer(0.07).minimize(cost)
TensorFlow-Sitzung:
with tf.Session() as sess:
merged = tf.summary.merge_all()
writer = tf.summary.FileWriter(log_file, sess.graph)
Hinweis: Zusammengeführtes und Schreibprogramm sind Teil der TensorBoard-Strategie, um das Verhalten des Modells zu verfolgen.
init = tf.global_variables_initializer()
sess.run(init)
Wiederholung des 1,5k-fachen der Trainingsschleife:
for step in range(1500):
result, _ = sess.run([merged, optimizer], feed_dict={X: np.asarray(train_X), Y: np.asarray(train_Y)})
writer.add_summary(result, step)
Schulungskosten drucken:
training_cost = sess.run(cost, feed_dict={X: np.asarray(train_X), Y: np.asarray(train_Y)})
print "Training Cost: ", training_cost, "W=", sess.run(W), "b=", sess.run(b), '\n'
Konkrete Vorhersage basierend auf dem trainierten Modell:
print "Prediction for 3.5 years"
predict_X = np.array([3.5], dtype=np.float32).reshape([1, 1])
predict_X = (predict_X - mean) / std
predict_Y = tf.add(tf.matmul(predict_X, W), b)
print "Child height(Y) =", sess.run(predict_Y)
Hauptroutine
def main():
train_X, train_Y = read_data()
train_X = feature_normalize(train_X)
run_training(train_X, train_Y)
Hinweis: Denken Sie an die Abhängigkeiten der Überprüfungsfunktionen. read_data , feature_normalize und run_training
Normalisierungsroutine
def feature_normalize(train_X):
global mean, std
mean = np.mean(train_X, axis=0)
std = np.std(train_X, axis=0)
return np.nan_to_num((train_X - mean) / std)
Datenroutine lesen
def read_data():
global m, n
m = 50
n = 1
train_X = np.array(
Interne Daten für das Array
).astype('float32')
train_Y = np.array(
Interne Daten für das Array
).astype('float32')
return train_X, train_Y
