使用ニューラルネットワークは、方形波機能好奇心のうち

Question

を学ぶために、私は、次の一つとして、方形波関数を学習するtensorflowを使用した簡単な完全に接続されたNNを構築しようとしています：

したがって入力します1Dのx値の配列（水平軸として）、出力はバイナリスカラー値です。私は、損失関数としてtf.nn.sparse_softmax_cross_entropy_with_logitsを使用し、tf.nn.reluを有効化として使用しました。 3つの隠れた層（100 * 100 * 100）と1つの入力ノードと出力ノードがあります。入力データは上記の波形に一致するように生成されるため、データサイズは問題にはなりません。

しかし、訓練されたモデルは、失敗すると思われ、常に負のクラスを予測します。

だから私はこれがなぜ起こったのか理解しようとしています。 NN構成が準最適であるかどうか、または表面の下のNNの数学的な欠陥に起因するかどうか（NNはどのような機能も模倣できるはずだと思いますが）。

ありがとうございました。

---

コメントセクションの示唆には、完全なコードがあります。私が先に間違っていると言って気づいたことの一つは、（原因2つの出力クラスに）2つの出力ノードが実際にありました：

""" 
    See if neural net can find piecewise linear correlation in the data 
""" 

import time 
import os 
import tensorflow as tf 
import numpy as np 

def generate_placeholder(batch_size): 
    x_placeholder = tf.placeholder(tf.float32, shape=(batch_size, 1)) 
    y_placeholder = tf.placeholder(tf.float32, shape=(batch_size)) 
    return x_placeholder, y_placeholder 

def feed_placeholder(x, y, x_placeholder, y_placeholder, batch_size, loop): 
    x_selected = [[None]] * batch_size 
    y_selected = [None] * batch_size 
    for i in range(batch_size): 
     x_selected[i][0] = x[min(loop*batch_size, loop*batch_size % len(x)) + i, 0] 
     y_selected[i] = y[min(loop*batch_size, loop*batch_size % len(y)) + i] 
    feed_dict = {x_placeholder: x_selected, 
       y_placeholder: y_selected} 
    return feed_dict 

def inference(input_x, H1_units, H2_units, H3_units): 

    with tf.name_scope('H1'): 
     weights = tf.Variable(tf.truncated_normal([1, H1_units], stddev=1.0/2), name='weights') 
     biases = tf.Variable(tf.zeros([H1_units]), name='biases') 
     a1 = tf.nn.relu(tf.matmul(input_x, weights) + biases) 

    with tf.name_scope('H2'): 
     weights = tf.Variable(tf.truncated_normal([H1_units, H2_units], stddev=1.0/H1_units), name='weights') 
     biases = tf.Variable(tf.zeros([H2_units]), name='biases') 
     a2 = tf.nn.relu(tf.matmul(a1, weights) + biases) 

    with tf.name_scope('H3'): 
     weights = tf.Variable(tf.truncated_normal([H2_units, H3_units], stddev=1.0/H2_units), name='weights') 
     biases = tf.Variable(tf.zeros([H3_units]), name='biases') 
     a3 = tf.nn.relu(tf.matmul(a2, weights) + biases) 

    with tf.name_scope('softmax_linear'): 
     weights = tf.Variable(tf.truncated_normal([H3_units, 2], stddev=1.0/np.sqrt(H3_units)), name='weights') 
     biases = tf.Variable(tf.zeros([2]), name='biases') 
     logits = tf.matmul(a3, weights) + biases 

    return logits 

def loss(logits, labels): 
    labels = tf.to_int32(labels) 
    cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=labels, logits=logits, name='xentropy') 
    return tf.reduce_mean(cross_entropy, name='xentropy_mean') 

def inspect_y(labels): 
    return tf.reduce_sum(tf.cast(labels, tf.int32)) 

def training(loss, learning_rate): 
    tf.summary.scalar('lost', loss) 
    optimizer = tf.train.GradientDescentOptimizer(learning_rate) 
    global_step = tf.Variable(0, name='global_step', trainable=False) 
    train_op = optimizer.minimize(loss, global_step=global_step) 
    return train_op 

def evaluation(logits, labels): 
    labels = tf.to_int32(labels) 
    correct = tf.nn.in_top_k(logits, labels, 1) 
    return tf.reduce_sum(tf.cast(correct, tf.int32)) 

def run_training(x, y, batch_size): 
    with tf.Graph().as_default(): 
     x_placeholder, y_placeholder = generate_placeholder(batch_size) 
     logits = inference(x_placeholder, 100, 100, 100) 
     Loss = loss(logits, y_placeholder) 
     y_sum = inspect_y(y_placeholder) 
     train_op = training(Loss, 0.01) 
     init = tf.global_variables_initializer() 
     sess = tf.Session() 
     sess.run(init) 
     max_steps = 10000 
     for step in range(max_steps): 
      start_time = time.time() 
      feed_dict = feed_placeholder(x, y, x_placeholder, y_placeholder, batch_size, step) 
      _, loss_val = sess.run([train_op, Loss], feed_dict = feed_dict) 
      duration = time.time() - start_time 
      if step % 100 == 0: 
       print('Step {}: loss = {:.2f} {:.3f}sec'.format(step, loss_val, duration)) 
    x_test = np.array(range(1000)) * 0.001 
    x_test = np.reshape(x_test, (1000, 1)) 
    _ = sess.run(logits, feed_dict={x_placeholder: x_test}) 
    print(min(_[:, 0]), max(_[:, 0]), min(_[:, 1]), max(_[:, 1])) 
    print(_) 

if __name__ == '__main__': 

    population = 10000 

    input_x = np.random.rand(population) 
    input_y = np.copy(input_x) 

    for bin in range(10): 
     print(bin, bin/10, 0.5 - 0.5*(-1)**bin) 
     input_y[input_x >= bin/10] = 0.5 - 0.5*(-1)**bin 

    batch_size = 1000 

    input_x = np.reshape(input_x, (population, 1)) 

    run_training(input_x, input_y, batch_size) 

サンプル出力はmin(_[:, 0])によって示されるように、モデルが常に、二以上の最初のクラスを好むことを示しています>max(_[:, 1])、すなわち、第1クラスの最小ロジット出力は、第2クラスの最大ロジット出力よりも大きい。サンプルサイズは、​​である。

---

私の間違い。問題はラインで発生しました：

for i in range(batch_size): 
    x_selected[i][0] = x[min(loop*batch_size, loop*batch_size % len(x)) + i, 0] 
    y_selected[i] = y[min(loop*batch_size, loop*batch_size % len(y)) + i] 

Pythonは同じ値にx_selectedのリスト全体を変異されます。今、このコードの問題は解決されました。修正は次のとおりです。

x_selected = np.zeros((batch_size, 1)) 
y_selected = np.zeros((batch_size,)) 
for i in range(batch_size): 
    x_selected[i, 0] = x[(loop*batch_size + i) % x.shape[0], 0] 
    y_selected[i] = y[(loop*batch_size + i) % y.shape[0]] 

この修正後、モデルのバリエーションが増えています。現在、x < = 0.5のクラス0を出力し、x> 0.5のクラス1を出力します。しかしこれは理想からまだ遠いです。

---

だから* 4層100個のノードにネットワーク構成を変更した後、100万のトレーニング手順（バッチサイズ= 100、サンプルサイズ= 10万円）した後、モデルは非常によくエッジでのみエラーを示す行っていますyが反転するとき。 したがって、この質問は終了しました。

Answer 1

あなたは本質的にperiodic functionを学ぼうとしますが、その機能は高度に非線形で滑らかではありません。だから、それは見た目が単純ではありません。要するに、入力機能のより良い表現が役立ちます。

期間がT = 2,f(x) = f(x+2)であるとします。 入力/出力が整数の場合の問題を軽減するため、関数はf(x) = 1 if x is odd else -1.です。この場合、問題は奇数と偶数を区別するためにニューラルネットワークを訓練するthis discussionに減らされます。

入力が浮動小数点数である一般的なケースでも、そのポストの2番目の箇条書きが役立つはずです。

固定長の精度で2進数で表現してみてください。

上記の縮小された問題では、最下位ビットがわかっていると出力が決定されることは容易にわかります。

decimal binary -> output 
1:  0 0 1 -> 1 
2:  0 1 0 -> -1 
3:  0 1 1 -> 1 
...