Могу ли я провести обучение для глубокой нейронной сети для части входов, а затем проверить для других частей тех же входных данных - PullRequest
Новая
       2

Могу ли я провести обучение для глубокой нейронной сети для части входов, а затем проверить для других частей тех же входных данных

0 голосов
/ 08 октября 2019

Я спрашиваю, возможно ли обучить глубокую нейронную сеть на основе части входных данных, а затем выполнить тест других частей ввода.

Исходя из того, что я понял, глубокая нейронная сеть начинает проводить обучение для известных данных, а затем, когда стоимость таких функций становится минимальной, она начинает выполнять тестирование.

То, что я пытаюсь сделать, - это выполнить обучение и тестирование для всех входных данных, для которых известен, например, первый квартал данных, а затем я выполняю обучение на основе этой известной половины данных до получениядо такого порога стоимости функции, после этого выполнить тестирование для моей второй половины данных и так далее. это возможно?

Например, предположим, что у меня есть входные данные размером $ n $, первая часть входных данных размера $ n / 4 $ известна, поэтому мне нужно выполнить обучение для этой части до достижения порогапотеря меньше, чем, например, 0,08, а затем использовать обученную нейронную сеть для другой части данных.

Я создал следующий код: 

import numpy as np
import tensorflow as tf

#generate random training data 
train_data = np.random.binomial(n=1, p=0.5, size = (8,))

def input_data(train_data):

   #generate random testing data 
    test_data= np.random.binomial(n=1, p=0.5, size = (32,))

    Y = np.concatenate(train_data , test_dat)
    return Y

# Create Neural network 
n_hidden_1 = 1024  # 
n_output= 8  #Number of output data
n_input = 8  #size of received data, it will be taken by smaller data of size 8

def encoder(x):
    weights = {
        'encoder_h1': tf.Variable(initializer([n_input, n_hidden_1])),
        'encoder_h2': tf.Variable(initializer([n_hidden_1, n_output])),
    }

    biases = {
        'encoder_b1': tf.Variable(initializer([n_hidden_1])),
        'encoder_b5': tf.Variable(initializer([n_output])),

    }
    layer_1 = tf.nn.tanh(tf.add(tf.matmul(x, weights['encoder_h1']), biases['encoder_b1']))
    layer_2 = tf.nn.tanh(tf.add(tf.matmul(layer_1, weights['encoder_h2']), biases['encoder_b2']))

    return layer_2

y_pred = encoder(X)
y_true = Y

cost = tf.reduce_mean(tf.pow(y_true - y_pred, 2))
learning_rate = tf.placeholder(tf.float32, shape=[])
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize(cost)
init = tf.global_variables_initializer()

#Perform training for first part and then testing 

traing_epochs = 1001
l_rate = 0.001
total_batch = 20  # number of batches per epoch
batch_size = 1000
input_samples_train = []
input_labels_train = []

input_labels_test = []
input_samples_test = []
test_number = 100000
sess.run(init)
for i in range(0, test_number):
    inputs = np.random.binomial(n=1, p=0.5, size=(32,))
    signal_output  = input_data(train_data)

    #get the training and testing data
    inputs_label_training = signal_output[0:8:1]
    inputs_sample_training = train_data

    input_labels_train.append(inputs_label_training )
    input_samples_train.append(inputs_sample_training )

    batch_x = np.asarray(input_samples_train)
    batch_y = np.asarray(input_labels_train)

    #Extracting the testing data 
    inputs_label_testing = inputs
    inputs_samples_testing = signal_output[8:40:1]

    input_labels_test.append(inputs_label_testing )
    input_samples_test.append(signal_output)

    #Start training
    for epoch in range(traing_epochs):
        avg_cost = 0.

        #Parameters of testing
        batch_test_x = np.asarray(input_labels_test)
        batch_test_y = np.asarray(input_samples_test)

        for index_m in range(total_batch):
            for index_k in range(0, batch_size):
                _, cs = sess.run([optimizer, cost], feed_dict={X: batch_x,
                                                               Y: batch_y,
                                                               learning_rate: l_rate})
                avg_cost += cs / total_batch
                #When the cost function is smaller than threshold
                if (avg_cost <= 0.08):
                #take the received data by same size of training data of 8                        
                        temp_list = []
                        for i in range(0,32,8):
                            mean_error = tf.reduce_mean(abs(y_pred - batch_y))  # mean_error.eval({X:batch_x}),
                            mean_error_rate = 1 - tf.reduce_mean(tf.reduce_mean(tf.to_float(tf.equal(tf.sign(y_pred - 0.5), tf.cast(tf.sign(batch_y - 0.5), tf.float32))),1))
                            temp_list.append(cs)

Мой вопрос, во-первых, возможно ли то, что я объяснил в начале, можно сделать с помощью глубокой нейронной сети? Я имею в виду использовать часть входных данных для обучения, а затем подавать остальные входные данные для тестирования? и во-вторых, последняя часть моего кода верна? Я имею в виду часть, которая касается тестирования после окончания обучающей части и установки порога? чтобы быть более конкретным, в этой части: 

#Start training
        for epoch in range(traing_epochs):
            avg_cost = 0.

            #Parameters of testing
            batch_test_x = np.asarray(input_labels_test)
            batch_test_y = np.asarray(input_samples_test)

            for index_m in range(total_batch):
                for index_k in range(0, batch_size):
                    _, cs = sess.run([optimizer, cost], feed_dict={X: batch_x,
                                                                   Y: batch_y,
                                                                   learning_rate: l_rate})
                    avg_cost += cs / total_batch

                    #When the cost function is smaller than threshold
                    if (avg_cost <= 0.08):
                    #take the received data by same size of training data of 8                        
                            temp_list = []
                            for i in range(0,32,8):
                                mean_error = tf.reduce_mean(abs(y_pred - batch_y))  # mean_error.eval({X:batch_x}),
                                mean_error_rate = 1 - tf.reduce_mean(tf.reduce_mean(tf.to_float(tf.equal(tf.sign(y_pred - 0.5), tf.cast(tf.sign(batch_y - 0.5), tf.float32))),1))
                                temp_list.append(cs)

Я пытался сделать это таким образом, но я не смог, не могли бы вы подсказать мне, как это сделать?

Заранее спасибо.

...