Tensorflow Nueral Réseau ne fonctionne pas

Question

merci d'avoir réfléchi à ma question. J'ai un problème à l'aide tensorflow où que je entrée mes données et je continue à obtenir la sortie:

('Epoch ', 0, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 1, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 2, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 3, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 4, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 5, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 6, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 7, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 8, ' completed out of ', 10, 'loss:', nan) 
('Epoch ', 9, ' completed out of ', 10, 'loss:', nan) 
('Accuracy:', 1.0) 

données

Mon X_train est un 500 par 1000 matrice où chaque ligne se composent de nombres tels que:

-0.38484444, 1.4542222222 ... 

J'espère que vous aurez l'idée ... Et mes données Y_train se composent de classifications binaires (0, 1). len (X_train [0]) renvoie 1000, ce qui correspond à la quantité d'échantillons (colonnes)

Je ne sais pas trop quoi d'autre j'ai besoin de clarifier à propos de mon problème; Je vais inclure mon code TensorFlow simple, et s'il vous plaît, si vous avez besoin de plus de précisions sur mon code ou problème s'il vous plaît faites le moi savoir.

Merci pour votre temps

import tensorflow as tf 
import pandas as pd 
import numpy as np 

da = pd.read_csv("data.csv", header=None) 
ta = pd.read_csv("BMI.csv") 

X_data = da.iloc[:, :1000] 
Y_data = np.expand_dims(ta.iloc[:, -1], axis = 1) 

X_train = X_data.iloc[:500 :,] 
X_test = X_data.iloc[500:,:] 

Y_train = Y_data[:500 :,] 
Y_test = Y_data[735:,:] 


X_train = np.array(X_train) 
X_test = np.array(X_test) 

n_nodes_hl1 = 500 
n_nodes_hl2 = 500 
n_nodes_hl3 = 500 

n_classes = 1 
batch_size = 10 

x = tf.placeholder('float', [None, len(X_train[0])]) 
y = tf.placeholder('float') 

def neural_network_model(data): 
    hidden_1_layer = {'weights': tf.Variable(tf.random_normal([len(X_train[0]), n_nodes_hl1])), 
         'biases': tf.Variable(tf.random_normal([n_nodes_hl1]))} 
    hidden_2_layer = {'weights': tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])), 
         'biases': tf.Variable(tf.random_normal([n_nodes_hl2]))} 
    hidden_3_layer = {'weights': tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])), 
         'biases': tf.Variable(tf.random_normal([n_nodes_hl3]))} 
    output_layer = {'weights': tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])), 
         'biases': tf.Variable(tf.random_normal([n_classes]))} 

    l1 = tf.add(tf.matmul(data, hidden_1_layer['weights']), hidden_1_layer['biases']) 
    l1 = tf.nn.relu(l1) 

    l2 = tf.add(tf.matmul(l1, hidden_2_layer['weights']), hidden_2_layer['biases']) 
    l2 = tf.nn.relu(l2) 

    l3 = tf.add(tf.matmul(l2, hidden_3_layer['weights']), hidden_3_layer['biases']) 
    l3 = tf.nn.relu(l3) 

    output = tf.matmul(l3, output_layer['weights']) + output_layer['biases'] 

    return output 


def train_nueral_network(x): 
    prediction = neural_network_model(x) 
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=prediction, labels=y)) 
    optimizer = tf.train.AdamOptimizer().minimize(cost) 

    hm_epochs = 10 

    with tf.Session() as sess: 
     sess.run(tf.global_variables_initializer()) 

     for epoch in range(hm_epochs): 
      epoch_loss = 0 

      i = 0 
      while i < len(X_train[0]): 
       start = i 
       end = i + batch_size 

       batch_x = np.array(X_train[start:end]) 
       batch_y = np.array(Y_train[start:end]) 

       _, c = sess.run([optimizer, cost], feed_dict= {x: batch_x, y: batch_y}) 
       epoch_loss += c 
       i += batch_size 


      print('Epoch ', epoch, ' completed out of ', hm_epochs, 'loss:', epoch_loss) 

     correct = tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1)) 
     accuracy = tf.reduce_mean(tf.cast(correct, 'float')) 
     print('Accuracy:', accuracy.eval({x:X_test, y:Y_test})) 


train_nueral_network(x) 

Answer 1

Vous pouvez remplacer le tf.nn.relu avec tf.nn.tanh et former à nouveau, et vérifier si vous obtenez les mêmes résultats. Parfois, ReLU induit le problème de gradient de fuite.

https://ayearofai.com/rohan-4-the-vanishing-gradient-problem-ec68f76ffb9b

Answer 2

Votre n_classes=1. Ainsi, vous appliquez softmax sur un seul neurone qui devrait toujours évaluer à 1. Vous devez définir n_classes=2.

En outre, dans le contexte actuel, l'évaluation de la précision que vous utilisez toujours 100% correct:

correct = tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1)) 

Ceci est parce que les deux prediction et y sont de forme (BATCH_SIZE,1) donc arg toujours conduire à 0 pour tous les échantillons.

Je conseillerais de représenter y dans une représentation à chaud. Une fois que vous le faites, le reste de votre code devrait fonctionner.