Python - Tensorflow, 이진 분류, 항상 예측 0

Question

저는 Tensorflow로 시작하여 이진 분류 용으로 고전적인 신경망을 만들려고합니다.

# Loading Dependencies 

import math 
import numpy as np 
import pandas as pd 
import tensorflow as tf 
from tensorflow.python.framework import ops 
from sklearn.model_selection import train_test_split 
import matplotlib.pyplot as plt 

seed = 1234 
tf.set_random_seed(seed) 
np.random.seed(seed) 

# Load and Split data 
data = pd.read_json(file) 
X = data["X"] 
y = data["y"] 
X = X.astype(np.float32) 
y = y.astype(np.float32) 

X_train, X_valid, y_train, y_valid = train_test_split(X, y, test_size = 0.3) 

X_train = X_train.reshape(X_train.shape[0], -1).T 
y_train = y_train.values.reshape((1, y_train.shape[0])) 
X_valid = X_valid.reshape(X_valid.shape[0], -1).T 
y_valid = y_valid.values.reshape((1, y_valid.shape[0])) 

print("X Train: ", X_train.shape) 
print("y Train: ", y_train.shape) 
print("X Dev: ", X_valid.shape) 
print("y Dev: ", y_valid.shape) 

X 트레인 (16875, 1122)
Y 열차 (1, 1122)
X 데브 (16,875, 482)
Y 데브 (1, 482)

트레이닝 데이터에는 부동 소수점 숫자가 포함되어 있지만 레이블은 0 또는 1입니다. 그러나 이전에는 몇 가지 문제가 있었기 때문에 이것도 float로 변환됩니다.

초기화 파라미터

def initialize_parameters(layer_dimensions): 
    tf.set_random_seed(seed) 
    layers_count = len(layer_dimensions) 
    parameters = {} 

    for layer in range(1, layers_count): 
     parameters['W' + str(layer)] = tf.get_variable('W' + str(layer), 
                [layer_dimensions[layer], layer_dimensions[layer - 1]], 
                initializer = tf.contrib.layers.xavier_initializer(seed = seed)) 

     parameters['b' + str(layer)] = tf.get_variable('b' + str(layer), 
                [layer_dimensions[layer], 1], 
                initializer = tf.zeros_initializer()) 

    return parameters 

모양은 :
W1 - (50, 16,875)
W2 - (25, 50)
W3 - (10, 25)
W4 - (5- 10)
W5 - (1,5)
(B1) - (50, 1)
B2 - (25, 1)
B3 - (10, 1) B4 - (5, 1)
B5 - (1, 1)

내가 수와 내가 모델을 호출하고 각 층의 치수를 지정하고

앞으로 전파 (아래 참조)

def forward_propagation(X, parameters): 
    parameters_count = len(parameters) // 2 
    A = X 

    for layer in range(1, parameters_count): 
     W = parameters['W' + str(layer)] 
     b = parameters['b' + str(layer)] 

     Z = tf.add(tf.matmul(W, A), b) 
     A = tf.nn.relu(Z) 

    W = parameters['W' + str(parameters_count)] 
    b = parameters['b' + str(parameters_count)] 

    Z = tf.add(tf.matmul(W, A), b) 

    return Z 

계산 비용 (나는 우리가 이진 분류를 다루고 있기 때문에 시그 모이 드 함수를 사용하고 있습니다)

def compute_cost(Z, Y):  
    logits = tf.transpose(Z) 
    labels = tf.transpose(Y) 

    cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits = logits, labels = labels)) 
    return cost 

내 모델을 학습 할 때 617,451,515,

이제 함께

def model(X_train, y_train, X_valid, y_valid, layer_dimensions, alpha = 0.0001, epochs = 10): 

    ops.reset_default_graph() 
    tf.set_random_seed(seed) 

    (x_rows, m) = X_train.shape 
    y_rows = y_train.shape[0] 

    costs = [] 

    X = tf.placeholder(tf.float32, shape=(x_rows, None), name="X") 
    y = tf.placeholder(tf.float32, shape=(y_rows, None), name="y") 

    parameters = initialize_parameters(layer_dimensions) 
    Z = forward_propagation(X, parameters) 
    cost = compute_cost(Z, y) 
    optimizer = tf.train.AdamOptimizer(learning_rate = alpha).minimize(cost) 

    init = tf.global_variables_initializer() 
    with tf.Session() as sess: 
     sess.run(init) 
     for epoch in range(epochs): 
      _ , epoch_cost = sess.run([optimizer, cost], feed_dict={X: X_train, y: y_train}) 
      print ("Cost after epoch %i: %f" % (epoch + 1, epoch_cost)) 
      costs.append(epoch_cost) 

     parameters = sess.run(parameters) 

     correct_predictions = tf.equal(tf.argmax(Z), tf.argmax(y)) 
     accuracy = tf.reduce_mean(tf.cast(correct_predictions, "float")) 

     print ("Train Accuracy:", accuracy.eval({X: X_train, y: y_train})) 
     print ("Test Accuracy:", accuracy.eval({X: X_valid, y: y_valid})) 

     return parameters 

그것을 퍼팅이에이 시대 이후

parameters = model(X_train, y_train, X_valid, y_valid, [X_train.shape[0], 50, 25, 10, 5, 1]) 

비용에 그 시점에서 거의 두 번째 시대에서 최적의 및 비용 변경에 도달 나타납니다 1 : 8.758244
비용 후 에포크 2 : 0.693096
비용 에포크 이후 3 : 0.692992
비용 에포크 4 일 : 0.692737
,691 363,210 비용 후 에포크 5 : 0.697333
비용 후 에포크 6 : 0.693062
비용 후 에포크 7 : 0.693151
비용 후 에포크 8 : 0.693152
비용 후 에포크 9 : 0.693155

: 0.693152
비용 에포크 10 후 예측

def predict(X, parameters): 
    parameters_count = len(parameters) // 2 
    params = {} 

    for layer in range(1, parameters_count + 1): 
     params['W' + str(layer)] = tf.convert_to_tensor(parameters['W' + str(layer)]) 
     params['b' + str(layer)] = tf.convert_to_tensor(parameters['b' + str(layer)]) 

    (x_columns, x_rows) = X.shape 
    X_test = tf.placeholder(tf.float32, shape=(x_columns, x_rows)) 

    Z = forward_propagation(X_test, params) 
    p = tf.argmax(Z) 

    sess = tf.Session() 
    prediction = sess.run(p, feed_dict = {X_test: X}) 

    return prediction 

이제

그러나, 이는 모든 경우에 0을 예측할 것이다 ..

predictions = predict(X_valid, parameters) 
predictions 

어레이 ([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 는 0, 0, 0, 0, 0 ....

Answer 1

X Train: (16875, 1122) 

당신은 각 샘플 16,875 기능 만 1,122 기차 데이터를 가지고있다. 나는이 충분하지 않은 것 같아요.

tensorflow의 샘플 코드는 784 개 기능을한다-시작.

x = tf.placeholder(tf.float32, shape=[None, 784]) 
y_ = tf.placeholder(tf.float32, shape=[None, 10]) 

MNIST 데이터는 55,000 데이터 포인트의 교육 데이터 (mnist.train), 10,000 포인트의 테스트 데이터 (mnist.test) 및 5,000 개의 유효 포인트 데이터 (mnist.validation)로 세 부분으로 나뉩니다. 이 분할은 매우 중요합니다. 기계 학습에서 필수적입니다. 우리가 배우지 않은 별도의 데이터를 가지고 있으므로 배운 내용이 실제로 일반화되었는지 확인할 수 있습니다! https://www.tensorflow.org/get_started/mnist/beginners