このモデルで素数をほぼ認識できるようにNNを訓練することは可能ですか？

Question

私は機械学習が初めてです。 Hello Worldのサンプルを実行しようとしましたhttps://www.tensorflow.org/get_started/mnist/beginners：

• 再帰的降下。
• Y =ソフトマックス（Wxを+ b）は
• コスト関数= cross_entropy

そしてそれは働きました。次のデータセットで次の試み

：

• X - 範囲（0、100000）
• Y - [Xにおけるxのis_prime（X）]

（調整されたWとBの寸法）

私が見ているところでは、Wとbは訓練プロセスで一定であるということです。

質問：

が、それはバグです私のコードで、または全体の数学的概念でありますか？

おかげでここに（該当する場合）

コード：

#!/usr/bin/python 

import tensorflow as tf 
import numpy as np 
import math 
import sys 

def is_prime(n): 
    if n % 2 == 0: 
     return False 
    return all(n % i for i in range(3, int(math.sqrt(n)) + 1, 2)) 

NUM_FEATURES = 32 
NUM_LABELS = 2 
DATA_SET_SIZE = 100000 
BATCH_SIZE = 100 
NUM_BATCHES = DATA_SET_SIZE/BATCH_SIZE 
NUM_TEST_BATCHES = 1 
NUM_TRAINING_BATCHES = NUM_BATCHES - NUM_TEST_BATCHES 
NUM_TRAINING_CYCLES = NUM_TRAINING_BATCHES 
NUM_TRAINING_DISPLAY_STEPS = 10 
TRAINING_DISPLAY_STEP_SIZE = NUM_TRAINING_CYCLES/NUM_TRAINING_DISPLAY_STEPS 

def convert_data(fvecs, labels): 
    fvecs_np = np.matrix(fvecs).astype(np.float32) 
    labels_np = np.array(labels).astype(dtype=np.uint8) 

    labels_onehot = (np.arange(NUM_LABELS) == labels_np[:, None]).astype(np.float32) 
    sys.stdout.flush() 
    return fvecs_np, labels_onehot 

def to_bits(x): 
    return [x & (1 << b) for b in range(NUM_FEATURES)] 


def training_data(): 
    #from tensorflow.examples.tutorials.mnist import input_data 
    #mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) 

    labels = [] 
    fvecs = [] 

    for x in range(DATA_SET_SIZE): 
     fvecs.append(to_bits(x)) 
     labels.append(is_prime(x)) 

    return convert_data(fvecs, labels) 

def test_data(): 
    return convert_data([to_bits(10), to_bits(15485867)], [False, True]) 

def variable_summaries(var): 
    """Attach a lot of summaries to a Tensor (for TensorBoard visualization).""" 
    with tf.name_scope('summaries'): 
     mean = tf.reduce_mean(var) 
     tf.summary.scalar('mean', mean) 
     with tf.name_scope('stddev'): 
      stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean))) 
     tf.summary.scalar('stddev', stddev) 
     tf.summary.scalar('max', tf.reduce_max(var)) 
     tf.summary.scalar('min', tf.reduce_min(var)) 
     tf.summary.histogram('histogram', var) 

#print len(primes) 
def main(): 

    # Build graph: 
    x = tf.placeholder(tf.float32, shape=[None, NUM_FEATURES]) 
    y_ = tf.placeholder(tf.float32, shape=[None, NUM_LABELS]) 

    with tf.name_scope('W'): 
     W = tf.Variable(tf.zeros([NUM_FEATURES, NUM_LABELS])) 
     variable_summaries(W) 

    with tf.name_scope('b'): 
     b = tf.Variable(tf.zeros([NUM_LABELS])) 
     variable_summaries(b) 

    with tf.name_scope("Wx_b"): 
     y = tf.nn.softmax(tf.matmul(x, W) + b) 

    with tf.name_scope("cross_entropy"): 
     cross_entropy = tf.reduce_mean(-tf.reduce_sum(y * tf.log(y), reduction_indices=[1])) 

    with tf.name_scope("train"): 
     train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy) 

    with tf.Session() as sess: 

     merged_summary_op = tf.summary.merge_all() 
     train_writer = tf.summary.FileWriter('train', sess.graph) 
     tf.global_variables_initializer().run() 
     avg_cost = 0 

     vecs, labels = training_data() 
     test_x, test_y = test_data() 
     print "Training..." 
     for batch in range(NUM_TRAINING_BATCHES): 
      batch_start = batch * BATCH_SIZE 
      batch_end = batch_start + BATCH_SIZE 
      batch_x_data = vecs[batch_start:batch_end] 
      batch_y_data = labels[batch_start:batch_end] 

      _    = sess.run(train_step,   feed_dict={x: batch_x_data, y_: batch_y_data}) 
      summary   = sess.run(merged_summary_op, feed_dict={x: batch_x_data, y_: batch_y_data}) 
      avg_cost  = sess.run(cross_entropy,  feed_dict={x: batch_x_data, y_: batch_y_data}) 
      test_cost  = sess.run(cross_entropy,  feed_dict={x: test_x, y_: test_y}) 

      train_writer.add_summary(summary, batch) 

      if batch % TRAINING_DISPLAY_STEP_SIZE == 0: 
       print "Iteration %04u: Cost = %.9f. Test cost: %.9f." % (batch, avg_cost, test_cost) 
     print "Done."   

     print "Testing..." 
     #vecs, labels = test_data() 
     print(sess.run(y, {x: vecs})) 

main() 

Answer 1

私はそれは不可能だと思います。機械学習法は、xをf（w; x）に写像する関数を学習するだけです。次に損失関数を損失（y、f（w; x））として定義します。 xは何かの特徴を表すベクトルです。天気xが素数であることを知らせる関数があれば、nnはそれを見つけるかもしれない。しかし、私はそのような関数があるとは思わない（おそらく存在しないので数学者は存在しないので）