損失関数の値は、新しいモデルの打ち上げごとに異なって収束します。

Question

私は、保険プライムを予測するための回帰を伴うニューラルネットワークモデルを構築します。私の損失関数はゼロに近づくまで減少しますが、損失関数の値はそれぞれの新しいモデルの打ち上げごとに異なって収束します。

... 
Epoch: 30/30 Train Loss: 0.1665 
Epoch: 30/30 Validation Loss: 1.2689 

... 
Epoch: 30/30 Train Loss: 4.6166 
Epoch: 30/30 Validation Loss: 4.4621 

... 
Epoch: 30/30 Train Loss: 1.3190 
Epoch: 30/30 Validation Loss: 1.3700 

損失が異なる値に収束するたびに正しいのですか？損失出力

モデルのコード次の値を予測する：

################# 
#TRAIN E TEST SET 
################# 
from sklearn.model_selection import train_test_split 

train_data, test_data = train_test_split(df, test_size=0.25) 

train_id=train_data["ID"] 
test_id=test_data["ID"] 

################## 
#TESNORFLOW MODEL 
################## 

from sklearn.preprocessing import LabelBinarizer 
from sklearn.model_selection import train_test_split 


############################ 
#Split training in validation 
############################ 

def split_valid_test_data(data, fraction=(1 - 0.8)): 
    data_y=train_data.as_matrix(columns=[train_data.columns[8]]) 
    data_x = data.drop(["Prime"], axis=1) 
    train_x, valid_x, train_y, valid_y = train_test_split(data_x, data_y, test_size=fraction) 
    return train_x.values, train_y, valid_x, valid_y 

train_x, train_y, valid_x, valid_y = split_valid_test_data(train_data) 

print("train_x:{}".format(train_x.shape)) 
print("train_y:{}".format(train_y.shape)) 
print("train_y content:{}".format(train_y[:3])) 

print("valid_x:{}".format(valid_x.shape)) 
print("valid_y:{}".format(valid_y.shape)) 


########## 
#Parameters 
########## 
learning_rate = 0.001 
training_epochs = 30 
batch_size =100 
display_step = 1 
total_len = train_x.shape[0] 
# Network Parameters 
n_hidden_1 = 16# 1st layer number of features 
n_hidden_2 = 14 # 2nd layer number of features 
n_hidden_3 = 12 
n_hidden_4 = 10 
n_input = train_x.shape[1] 
n_classes = 1 

############### 
#tf Graph input 
############### 

x = tf.placeholder("float", [None, train_x.shape[1]]) 
y = tf.placeholder("float", [None,n_classes]) 

################# 
#Model 
################# 

def multilayer_perceptron(x, weights, biases): 
    # Hidden layer with RELU activation 
    layer_1 = tf.add(tf.matmul(x, weights['h1']), biases['b1']) 
    layer_1 = tf.nn.relu(layer_1) 
    # Hidden layer with RELU activation 
    layer_2 = tf.add(tf.matmul(layer_1, weights['h2']), biases['b2']) 
    layer_2 = tf.nn.relu(layer_2) 
    # Hidden layer with RELU activation 
    layer_3 = tf.add(tf.matmul(layer_2, weights['h3']), biases['b3']) 
    layer_3 = tf.nn.relu(layer_3) 
    # Hidden layer with RELU activation 
    layer_4 = tf.add(tf.matmul(layer_3, weights['h4']), biases['b4']) 
    layer_4 = tf.nn.relu(layer_4) 
    # Output layer with linear activation 
    out_layer = tf.matmul(layer_4, weights['out']) + biases['out'] 
    return out_layer 

################################## 
#weight & bias 
################################## 
weights = { 
    'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1], 0,0.1, dtype=tf.float32)), 
    'h2': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], 0,0.1,dtype=tf.float32)), 
    'h3': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_3], 0,0.1,dtype=tf.float32)), 
    'h4': tf.Variable(tf.random_normal([n_hidden_3, n_hidden_4], 0,0.1,dtype=tf.float32)), 
    'out': tf.Variable(tf.random_normal([n_hidden_4, n_classes], 0, 0.1,dtype=tf.float32)) 
} 
biases = { 
    'b1': tf.Variable(tf.random_normal([n_hidden_1], 0,0.1,dtype=tf.float32)), 
    'b2': tf.Variable(tf.random_normal([n_hidden_2], 0,0.1,dtype=tf.float32)), 
    'b3': tf.Variable(tf.random_normal([n_hidden_3], 0,0.1,dtype=tf.float32)), 
    'b4': tf.Variable(tf.random_normal([n_hidden_4], 0,0.1,dtype=tf.float32)), 
    'out': tf.Variable(tf.random_normal([n_classes], 0, 0.1,dtype=tf.float32)) 
} 

pred= multilayer_perceptron(x, weights, biases) 

############################################## 
# loss e optimizer 
############################################### 

########### 
#MSE 
########### 

cost = tf.reduce_mean(tf.square(pred-y)) 

optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost) 

correct_prediction = tf.equal(tf.argmax(pred, 1), tf.argmax(y, 1)) 
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 

######## 
#batch 
######## 

def get_batch(data_x,data_y,batch_size): 
    batch_n=len(data_x)//batch_size 
    for i in range(batch_n): 
     batch_x=data_x[i*batch_size:(i+1)*batch_size] 
     batch_y=data_y[i*batch_size:(i+1)*batch_size] 
     yield batch_x,batch_y 

train_collect = 50 
train_print=train_collect*2 


x_collect = [] 
train_loss_collect = [] 
train_acc_collect = [] 
valid_loss_collect = [] 
valid_acc_collect = [] 

saver = tf.train.Saver() 

with tf.Session() as sess: 
    sess.run(tf.global_variables_initializer()) 
    iteration=0 
    for e in range(training_epochs) : 
     for batch_x,batch_y in get_batch(train_x,train_y,batch_size): 
      iteration+=1 
      feed = {x: train_x, 
        y: train_y 
        } 
      sess.run(optimizer, feed_dict={x:train_x, y: train_y}) 
      train_loss, train_acc = sess.run([cost, accuracy], feed_dict=feed) #_, optimizer 
      prediction_train = sess.run([pred], feed_dict=feed) 
      if iteration % train_collect == 0: 
       x_collect.append(e) 
       train_loss_collect.append(train_loss) 
       train_acc_collect.append(train_acc) 
       if iteration % train_print==0: 
        print("Epoch: {}/{}".format(e + 1, training_epochs), 
         "Train Loss: {:.4f}".format(train_loss), 
         "Train Acc: {:.4f}".format(train_acc))  
       feed = {x: valid_x, 
         y: valid_y 
         } 
       val_loss, val_acc = sess.run([cost, accuracy], feed_dict=feed) 
       valid_loss_collect.append(val_loss) 
       valid_acc_collect.append(val_acc) 
       if iteration % train_print==0: 
        print("Epoch: {}/{}".format(e + 1,training_epochs), 
         "Validation Loss: {:.4f}".format(val_loss), 
         "Validation Acc: {:.4f}".format(val_acc)) 
    saver.save(sess, "./prova_habitas.ckpt") 

Answer 1

時には、ニューラルネットワークは、初期化に非常に敏感です。 >最高の最後のものである -

は例

'h1': tf.Variable(tf.random_normal([n_input, n_hidden_1], 0,0.1, dtype=tf.float32) * 0.001)