Wie trainierst du ein lineares Modell im Tensorflow?

Question

Ich habe einige Eingabedaten in einer CSV generiert, wo "awesomeness" "age * 10" ist. Es sieht wie folgt aus:

age, awesomeness 
67, 670 
38, 380 
32, 320 
69, 690 
40, 400 

Es sollte trivial sein, ein tensorflow Modell zu schreiben, die ‚awesomeness‘ von ‚Alter‘ vorhersagen kann, aber ich kann es nicht funktionieren.

Wenn ich mit dem Training laufen, der Ausgang ich erhalte, ist:

accuracy: 0.0 <----------------------------------- What!?? 
accuracy/baseline_label_mean: 443.8 
accuracy/threshold_0.500000_mean: 0.0 
auc: 0.0 
global_step: 6000 
labels/actual_label_mean: 443.8 
labels/prediction_mean: 1.0 
loss: -2.88475e+09 
precision/positive_threshold_0.500000_mean: 1.0 
recall/positive_threshold_0.500000_mean: 1.0 

Bitte beachten Sie, dass dies offensichtlich ein völlig erfundenes Beispiel, aber das ist, weil ich das gleiche Ergebnis mit einem komplexeren aussagekräftigen Modell immer mit ein viel größerer Datensatz; 0% Genauigkeit

Dies ist mein Versuch, den minimal möglichen reproduzierbaren Testfall, den ich machen kann, der das gleiche Verhalten zeigt, zu versuchen.

Hier ist, was ich tue, auf der Grundlage der Volkszählung Beispiel für die DNNClassifier von tflearn:

COLUMNS = ["age", "awesomeness"] 
CONTINUOUS_COLUMNS = ["age"] 
OUTPUT_COLUMN = "awesomeness" 

def build_estimator(model_dir): 
    """Build an estimator.""" 
    age = tf.contrib.layers.real_valued_column("age") 
    deep_columns = [age] 

    m = tf.contrib.learn.DNNClassifier(model_dir=model_dir, 
            feature_columns=deep_columns, 
            hidden_units=[50, 10]) 
    return m 

def input_fn(df): 
    """Input builder function.""" 
    feature_cols = {k: tf.constant(df[k].values, shape=[df[k].size, 1]) for k in CONTINUOUS_COLUMNS} 
    output = tf.constant(df[OUTPUT_COLUMN].values, shape=[df[OUTPUT_COLUMN].size, 1]) 
    return feature_cols, output 

def train_and_eval(model_dir, train_steps): 
    """Train and evaluate the model.""" 
    train_file_name, test_file_name = training_data() 
    df_train = pd.read_csv(...) # ommitted for clarity 
    df_test = pd.read_csv(...) 

    m = build_estimator(model_dir) 
    m.fit(input_fn=lambda: input_fn(df_train), steps=train_steps) 

    results = m.evaluate(input_fn=lambda: input_fn(df_test), steps=1) 
    for key in sorted(results): 
    print("%s: %s" % (key, results[key])) 

def training_data(): 
    """Return path to the training and test data""" 
    training_datafile = path.join(path.dirname(__file__), 'data', 'data.training') 
    test_datafile = path.join(path.dirname(__file__), 'data', 'data.test') 
    return training_datafile, test_datafile 

model_folder = 'scripts/model' # Where to store the model 
train_steps = 2000 # How many iterations to run while training 
train_and_eval(model_folder, train_steps) 

Ein paar Anmerkungen:

• Das ursprüngliche Beispiel Tutorial dies basiert auf ist hier https://github.com/tensorflow/tensorflow/blob/master/tensorflow/examples/learn/wide_n_deep_tutorial.py

• Hinweis Ich verwende den DNNClassifier, nicht den LinearClassifier, wie ich speziell mit kontinuierlicher Inpu beschäftigen möchte t Variablen.

• Viele Beispiele verwenden nur 'vorgefertigte' Datensätze, von denen bekannt ist, dass sie mit Beispielen arbeiten; Mein Datensatz wurde manuell erstellt und ist absolut nicht zufällig.

• Ich habe verifiziert, dass der CSV-Lader die Daten korrekt als int64 Werte lädt.

• Trainings- und Testdaten werden identisch generiert, haben jedoch unterschiedliche Werte. aber unter Verwendung von data.training als die Testdaten immer noch gibt eine Genauigkeit von 0% zurück, so dass es keine Frage ist, dass etwas nicht funktioniert, das ist nicht nur übermäßig anpassen.

Answer 1

Zunächst beschreiben Sie eine Regressionstask, keine Klassifizierungsaufgabe. Daher wäre sowohl DNNClassifier als auch LinearClassifier falsch zu verwenden. Das macht auch die Genauigkeit zur falschen Größe, um zu erkennen, ob Ihr Modell funktioniert oder nicht. Ich schlage vor, Sie lesen zu diesen zwei verschiedenen Kontext, z. in dem Buch "Die Elemente des statistischen Lernens"

Aber hier ist eine kurze Antwort auf Ihr Problem. Sagen Sie bitte

awesomeness_predicted = slope * age 

wo slope ist der Parameter Sie wollen aus den Daten ein lineares Modell lernen. Nehmen wir an, Sie haben Daten age[0], ..., age[N] und die entsprechenden ehrfürchtigen Werte a_data[0],...,a_data[N].Um zu bestimmen, ob Ihr Modell gut funktioniert, wir mittlere quadratische Fehler verwenden werden, das heißt

error = sum((a_data[i] - a_predicted[i])**2 for i in range(N)) 

Was möchten Sie jetzt tun, ist mit einer Zufallsvermutung für Steigung beginnen und allmählich mit Gradientenabfallsaktualisierung zu verbessern. Hier ist ein voll funktionierendes Beispiel in reinen tensorflow

import tensorflow as tf 
import numpy as np 

DTYPE = tf.float32 

## Generate Data 
age = np.array([67, 38, 32, 69, 40]) 
awesomeness = 10 * age 

## Generate model 
# define the parameter of the model 
slope = tf.Variable(initial_value=tf.random_normal(shape=(1,), dtype=DTYPE)) 
# define the data inputs to the model as variable size tensors 
x = tf.placeholder(DTYPE, shape=(None,)) 
y_data = tf.placeholder(DTYPE, shape=(None,)) 
# specify the model 
y_pred = slope * x 
# use mean squared error as loss function 
loss = tf.reduce_mean(tf.square(y_data - y_pred)) 
target = tf.train.AdamOptimizer().minimize(loss) 

## Train Model 
init = tf.global_variables_initializer() 
with tf.Session() as sess: 
    sess.run(init) 
    for epoch in range(100000): 
     _, training_loss = sess.run([target, loss], 
            feed_dict={x: age, y_data: awesomeness}) 
    print("Training loss: ", training_loss) 
    print("Found slope=", sess.run(slope)) 

Answer 2

Siehe auch https://github.com/tflearn/tflearn/blob/master/examples/basics/multiple_regression.py für die Verwendung von tflearn diese zu lösen.

""" Multiple Regression/Multi target Regression Example 

The input features have 10 dimensions, and target features are 2 dimension. 

""" 

from __future__ import absolute_import, division, print_function 

import tflearn 
import numpy as np 

# Regression data- 10 training instances 
#10 input features per instance. 
X=np.random.rand(10,10).tolist() 
#2 output features per instance 
Y=np.random.rand(10,2).tolist() 

# Multiple Regression graph, 10-d input layer 
input_ = tflearn.input_data(shape=[None,10]) 
#10-d fully connected layer 
r1 = tflearn.fully_connected(input_,10) 
#2-d fully connected layer for output 
r1 = tflearn.fully_connected(r1,2) 
r1 = tflearn.regression(r1, optimizer='sgd', loss='mean_square', 
             metric='R2', learning_rate=0.01) 

m = tflearn.DNN(r1) 
m.fit(X,Y, n_epoch=100, show_metric=True, snapshot_epoch=False) 

#Predict for 1 instance 
testinstance=np.random.rand(1,10).tolist() 
print("\nInput features: ",testinstance) 
print("\n Predicted output: ") 
print(m.predict(testinstance)) 

Answer 3

Es gibt ein paar Dinge, Ich mag würde sagen. Angenommen, Sie laden die Daten korrekt:

-Dies sieht wie eine Regressionstask aus und Sie verwenden einen Klassifikator. Ich sage nicht, dass es überhaupt nicht funktioniert, aber so gibst du jedem Eintrag von Alter und Training ein Etikett auf der ganzen Charge, jede Epoche ist sehr instabil.

-Sie erhalten einen großen Wert für den Verlust, Ihre Gradienten explodieren. Mit diesem Spieldatensatz müssen Sie wahrscheinlich Hyperparameter wie versteckte Neuronen, Lerngeschwindigkeit und Anzahl der Epochen abstimmen. Versuchen Sie, den Verlustwert für jede Epoche zu protokollieren, und sehen Sie, ob das das Problem sein könnte.

-Last Vorschlag, Ihre Daten Arbeit mit einem einfacheren Modell machen, möglicherweise geeignet für Ihre Aufgabe, wie ein regression model und dann vergrößert