Construire un réseau de neurones pour les sorties multiples

Question

Mes données d'entrée est la suivante:

AT V AP RH PE 
14.96 41.76 1024.07 73.17 463.26 
25.18 62.96 1020.04 59.08 444.37 
5.11 39.4 1012.16 92.14 488.56 
20.86 57.32 1010.24 76.64 446.48 
10.82 37.5 1009.23 96.62 473.9 
26.27 59.44 1012.23 58.77 443.67 
15.89 43.96 1014.02 75.24 467.35 
9.48 44.71 1019.12 66.43 478.42 
14.64 45 1021.78 41.25 475.98 
.................................... 

Je travaille essentiellement sur Python à l'aide tensorflow Library. A partir de maintenant, j'ai un modèle linéaire, qui fonctionne bien pour 4 entrées et 1 sortie. C'est fondamentalement un problème de régression. Par exemple: Après la formation de mon réseau de neurones avec des données suffisantes (disons si la taille des données est d'environ 10000), alors en formant mon réseau de neurones, si je passe les valeurs 45,30,25,32, en entrée, il est renvoyant la valeur 46 en sortie.

J'ai essentiellement deux requêtes:

1. A partir de maintenant, dans mon code, je suis en utilisant les paramètres training_epochs, learning_rate etc. Je suis aussi de donner maintenant la valeur de training_epochs comme 10000.So , quand je teste mon réseau neuronal en passant quatre valeurs d'entrée, je reçois la sortie comme quelque 471,25, alors que je m'attends à ce qu'il soit 460.Mais si je donne la valeur de training_epochs comme 20000, au lieu de 10000, Je reçois ma valeur de sortie en 120,5, ce qui n'est pas du tout clos e par rapport à la valeur réelle "460".

Pouvez-vous expliquer s'il vous plaît, comment peut-on choisir les valeurs de training_epochs et learning_rate (ou toute autre valeur de paramètre) dans mon code, afin que je puisse obtenir une bonne précision.

1. Maintenant, la deuxième question est, mon réseau de neurones à partir de maintenant travaille uniquement pour les données linéaires ainsi que seulement pour 1 sortie. Si je veux avoir 3 entrées et 2 sorties et aussi un modèle non-linéaire, quels sont les changements possibles dans mon code?

Je posterai mon code ci-dessous:

import tensorflow as tf 
import numpy as np 
import pandas as pd 
#import matplotlib.pyplot as plt 
rng = np.random 


# In[180]: 

# Parameters 
learning_rate = 0.01 
training_epochs = 10000 
display_step = 1000 


# In[171]: 

# Read data from CSV 

df = pd.read_csv("H:\MiniThessis\Sample.csv") 


# In[173]: 

# Seperating out dependent & independent variable 

train_x = df[['AT','V','AP','RH']] 
train_y = df[['PE']] 
trainx = train_x.as_matrix().astype(np.float32) 
trainy = train_y.as_matrix().astype(np.float32) 
# In[174]: 

n_input = 4 
n_classes = 1 
n_hidden_1 = 5 
n_samples = 9569 

# tf Graph Input 
#Inserts a placeholder for a tensor that will be always fed. 
x = tf.placeholder(tf.float32, [None, n_input]) 
y = tf.placeholder(tf.float32, [None, n_classes]) 

# Set model weights 
W_h1 = tf.Variable(tf.random_normal([n_input, n_hidden_1])) 
W_out = tf.Variable(tf.random_normal([n_hidden_1, n_classes])) 
b_h1 = tf.Variable(tf.random_normal([n_hidden_1])) 
b_out = tf.Variable(tf.random_normal([n_classes])) 


# In[175]: 

# Construct a linear model 
layer_1 = tf.matmul(x, W_h1) + b_h1 
layer_1 = tf.nn.relu(layer_1) 
out_layer = tf.matmul(layer_1, W_out) + b_out 


# In[176]: 

# Mean squared error 
cost = tf.reduce_sum(tf.pow(out_layer-y, 2))/(2*n_samples) 
# Gradient descent 
optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost) 


# In[177]: 

# Initializing the variables 
init = tf.global_variables_initializer() 


# In[181]: 

# Launch the graph 
with tf.Session() as sess: 
    sess.run(init) 

    # Fit all training data 
    for epoch in range(training_epochs): 
     _, c = sess.run([optimizer, cost], feed_dict={x: trainx,y: trainy}) 

     # Display logs per epoch step 
     if (epoch+1) % display_step == 0: 
      print("Epoch:", '%04d' % (epoch+1), "cost=", "{:.9f}".format(c)) 

    print("Optimization Finished!") 
    training_cost = sess.run(cost, feed_dict={x: trainx,y: trainy}) 
    print(training_cost) 

    correct_prediction = tf.equal(tf.argmax(out_layer, 1), tf.argmax(y, 1)) 
    best = sess.run([out_layer], feed_dict= 
    {x:np.array([[14.96,41.76,1024.07,73.17]])}) 
    print(correct_prediction) 

    print(best) 

Answer 1

1.you peut ajuster ces lignes suivantes;

# In general baises are either initialized as zeros or not zero constant, but not Gaussian 
b_h1 = tf.Variable(tf.zeros([n_hidden_1])) 
b_out = tf.Variable(tf.zeros([n_classes])) 

# MSE error 
cost = tf.reduce_mean(tf.pow(out_layer-y, 2))/(2*n_samples) 

De plus, alimentez les données en mini lots; comme l'optimiseur que vous utilisez est réglé pour l'optimisation de minibatch; l'alimentation des données dans son ensemble n'aboutit pas à des performances optimales.

2. Pour plusieurs sorties, vous devez modifier uniquement le n_classes et le coût de la fonction (tf.nn.softmax_cross_entropy_with_logits). De plus, le modèle que vous avez défini ici n'est pas linéaire. lorsque vous utilisez la fonction d'activation non linéaire tf.nn.relu.