Multivariable lineare Regression mit Tensorflow

Question

Ich wiederverwendet TensorFlow-Code für multivariable lineare Regression und versucht, die Kosten zu reduzieren, aber das Problem ist, dass nach einigen Iterationen die Kosten sowie die Werte von W und b Inf und schnell Nan wird. Kann mir bitte jemand sagen, wo das Problem liegt. Ich habe ungefähr 100.000 Werte. Ich habe es auf 10.000 Werte zum Testen getrimmt. Der Datensatz ist here

Hier ist der Code

import numpy as np 
import tensorflow as tf 



def computeX(): 

    all_xs = np.loadtxt("test.csv", delimiter=',', skiprows=1, usecols=range(4,260)) #reads the columns except first one 


    timestamps = np.loadtxt("test.csv", delimiter=',', skiprows=1, usecols=(0),dtype =str) 
    symbols = np.loadtxt("test.csv", delimiter=',', skiprows=1, usecols=(1),dtype =float) 
    categories = np.loadtxt("test.csv", delimiter=',', skiprows=1, usecols=(2),dtype =str) 

    tempList = [] 
    BOW = {"M1": 1.0, "M5": 2.0, "M15": 3.0, "M30": 4.0, "H1": 5.0, "H4": 6.0, "D1": 7.0} 

    #explode dates and make them features.. 2016/11/1 01:54 becomes [2016, 11, 1, 01, 54] 
    for i, v in enumerate(timestamps): 
     splitted = v.split() 
     dateVal = splitted[0] 
     timeVal = splitted[1] 
     ar = dateVal.split("/") 
     splittedTime = timeVal.split(":") 

     ar = ar + splittedTime 

     Features = np.asarray(ar) 
     Features = Features.astype(float) 

     # append symbols 

     Features = np.append(Features,symbols[i]) 

     #append categories from BOW 

     Features = np.append(Features, BOW[categories[i]]) 
     row = np.append(Features,all_xs[i]) 
     row = row.tolist() 
     tempList.append(row) 

    all_xs = np.array(tempList) 
    del tempList[:] 
    return all_xs 


if __name__ == "__main__": 
    print ("Starting....") 


    learn_rate = 0.5 

    all_ys = np.loadtxt("test.csv", delimiter=',', skiprows=1, usecols=3) 
#reads only first column 

    all_xs = computeX() 

    datapoint_size= int(all_xs.shape[0]) 

    print(datapoint_size) 
    x = tf.placeholder(tf.float32, [None, 263], name="x") 
    W = tf.Variable(tf.ones([263,1]), name="W") 
    b = tf.Variable(tf.ones([1]), name="b") 

    product = tf.matmul(x,W) 
    y = product + b 

    y_ = tf.placeholder(tf.float32, [datapoint_size]) 

    cost = tf.reduce_mean(tf.square(y_-y))/ (2*datapoint_size) 

    train_step = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost) 

    sess = tf.Session() 


    init = tf.global_variables_initializer() 
    sess.run(init) 

    batch_size = 10000 
    steps =10 
    for i in range(steps): 
     print("Entering Loop") 
     if datapoint_size == batch_size: 
     batch_start_idx = 0 
     elif datapoint_size < batch_size: 
     raise ValueError("datapoint_size: %d, must be greater than batch_size: %d" % (datapoint_size, batch_size)) 
     else: 
     batch_start_idx = (i * batch_size) % (datapoint_size - batch_size) 
     batch_end_idx = batch_start_idx + batch_size 
     batch_xs = all_xs[batch_start_idx:batch_end_idx] 
     batch_ys = all_ys[batch_start_idx:batch_end_idx] 
     xs = np.array(batch_xs) 
     ys = np.array(batch_ys) 

     feed = { x: xs, y_: ys } 

     sess.run(train_step, feed_dict=feed) 
     print("W: %s" % sess.run(W)) 
     print("b: %f" % sess.run(b)) 
     print("cost: %f" % sess.run(cost, feed_dict=feed)) 

Answer 1

einen Blick auf Ihre Daten nehmen:

id8   id9   id10 id11 id12 
1451865600 1451865600 -19.8 87.1 0.5701 
1451865600 1451865600 -1.6 3.6  0.57192 
1451865600 1451865600 -5.3 23.9 0.57155 

Sie auch Ihre Gewichte zu einem initialisieren, wenn Sie alle von Ihnen eingegebenen Daten multiplizieren mit Eins, und addieren sie, alle 'schweren' Spalten (ID8, ID9, usw., Spalten mit großen Zahlen) wird die Daten aus den kleineren Spalten wegschieben). Sie haben auch Spalten, die mit Nullen gefüllt sind:

id236 id237 id238 id239 id240 
0  0  0  0  0 
0  0  0  0  0 
0  0  0  0  0 

Das sind alles Dinge, die nicht gut zusammen spielen. Die großen Werte führen zu sehr hohen Vorhersagen, diese führen dazu, dass der Verlust explodiert und überläuft. Selbst wenn Sie Ihre Lernrate um den Faktor 1 Milliarde senken, hat das kaum Auswirkungen.

daher Vorschläge:

• Ihre Daten Überprüfen Sie, loszuwerden aller Unsinn Daten (Spalten mit Nullen gefüllt)
• Normalisieren Ihre Eingangsdaten
• an diesem Punkt Untersuchen Sie die Größe oder die Verlustfunktion und Versuchen Sie dann, mit der Lernrate zu spielen.