Tensor中的撲克手數據集流量精度很差

Question

我想訓練一個神經網絡Poker Hand Dataset（10類）。我試圖改變mnist檢查來適應這一點。但是，對於我的程序來說，準確度總是在50％左右，這太麻煩了。我如何提高準確度？

def init_weights(shape): 
    """ Weight initialization """ 
    weights = tf.random_normal(shape, stddev=0.1) 
    return tf.Variable(weights) 

def forwardprop(X, weights, biases): 
    """ 
    Forward-propagation. 
    IMPORTANT: yhat is not softmax since TensorFlow's softmax_cross_entropy_with_logits() does that internally. 
    """ 
    h = tf.nn.sigmoid(tf.add(tf.matmul(X, weights['w_1']),biases['b_1'])) # The \sigma function 
    yhat = tf.add(tf.matmul(h, weights['w_2']),biases['b_2']) # The \varphi function 
    return yhat 

def get_data(filename, targetname="target", idname="", test_size=0.10, random_state=200): 
    #read data from csv 
    df = pd.read_csv(filename) 
    data = pd.DataFrame(df.ix[:, df.columns != targetname]) 

    if(idname != str("")): 
     df = df.drop(idname, 1) 

    data = pd.DataFrame(df.ix[:, df.columns != targetname]) 
    data = pd.get_dummies(data) 
    all_X = data.as_matrix() 

    target = df[targetname] 
    target = pd.factorize(target)[0] 
    # Convert target into one-hot vectors 
    num_labels = len(np.unique(target)) 
    all_Y = np.eye(num_labels)[target] # One liner trick! 

    return train_test_split(all_X, all_Y, test_size=test_size, random_state=random_state) 

def main(): 
    start_time = time.time() 
    train_X, test_X, train_y, test_y = get_data(filename = './data/poker-train.csv', targetname = "class") 

    #customized for this dataset (or any large dataset), must be chosen as per the data, need to find some generic way 
    #for small datasets: batch size can be 1 (for more accuracy), 
    #for large ones: somewhr around 50-80, if taken 1 very slow,50-80 is a trade off of accuracy for time 
    learning_rate = 0.01 
    training_epochs = 100 
    batch_size = 1 

    # Layer's sizes 
    x_size = train_X.shape[1] # Number of input nodes 
    h_size = train_X.shape[1] # Number of hidden nodes 
    y_size = train_y.shape[1] # Number of outcomes 

    # Symbols 
    X = tf.placeholder("float", shape=[None, x_size]) 
    y = tf.placeholder("float", shape=[None, y_size]) 

    # Weight initializations 
    weights = { 
     'w_1' : init_weights((x_size, h_size)), 
     'w_2' : init_weights((h_size, y_size)) 
    } 

    # Bias initializations 
    biases = { 
     'b_1': init_weights([h_size]), 
     'b_2': init_weights([y_size]) 
    } 

    # Forward propagation 
    yhat = forwardprop(X, weights, biases) 
    predict = tf.argmax(yhat, axis=1) 

    # Backward propagation 
    cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=yhat)) 
    updates = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost) 

    # Run SGD 
    sess = tf.Session() 
    init = tf.global_variables_initializer() 
    sess.run(init) 

    total_batch = int(train_X.shape[0]/batch_size) 
    # Launch the graph 
    with tf.Session() as sess: 
     sess.run(init) 

     for epoch in range(training_epochs): 
      beg_i=0 
       # Loop over all batches 
      for i in range(total_batch): 
       end_i = beg_i + batch_size 
       if(end_i > train_X.shape[0]): 
        end_i = train_X.shape[0] 

       batch_x, batch_y = train_X[beg_i:end_i,:],train_y[beg_i:end_i,:] 
       beg_i = beg_i + batch_size 

       sess.run(updates, feed_dict={X: batch_x, y: batch_y}) 

      train_accuracy = np.mean(np.argmax(train_y, axis=1) == sess.run(predict, feed_dict={X: train_X, y: train_y})) 
      test_accuracy = np.mean(np.argmax(test_y, axis=1) == sess.run(predict, feed_dict={X: test_X, y: test_y})) 

      print("Epoch = %d, train accuracy = %.2f%%, test accuracy = %.2f%%" 
        % (epoch + 1, 100. * train_accuracy, 100. * test_accuracy)) 

     # # Test model 
     # correct_prediction = tf.equal(tf.argmax(predict, 1), tf.argmax(y, 1)) 
     # # Calculate accuracy 
     # accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) 
     # print("Accuracy:", accuracy.eval({X: test_X, y: test_y})) 

    print("Total time of execution: ",time.time()-start_time) 

if __name__ == '__main__': 
    main() 

輸出是

時代= 100，列車準確性= 55.77％，測試精度= 55.30％

時代= 1，火車準確性= 50.13％，測試精度= 50.20％

Answer 1

batch_size = 50#1 
training_epochs = int(train_X.shape[0]/batch_size) 

# Layer's sizes 
x_size = train_X.shape[1] # Number of input nodes 
h_size = 100#train_X.shape[1] # Number of hidden nodes 
y_size = train_y.shape[1] # Number of outcomes 

我修改如上。
時代= 1，火車精度= 49.98％，測試精度= 50.11％
時代= 500，列車精度= 90.90％，測試精度= 90.78％