python - machine - tensorflow sdk

Mejora de la precisión de una red neuronal Tensorflow: python

Question

Esta es la continuación de mi primera pregunta: recibir resultados de costos aleatorios en la regresión de tensorflow-python

Estoy usando un perceptrón ANN de varias capas para predecir el Phyla de muestras de bacterias en base a otros datos observados. Cada vez que ejecuto mi código obtengo una precisión de 0. El conjunto de datos no es el mejor ya que hay muchos NaN (que han sido reemplazados por 0), pero esperaba algo mejor que nada. Estoy buscando ayuda para depurar y mejorar la precisión

El conjunto de datos que estoy usando se puede encontrar aquí: https://github.com/z12332/tensorflow-test-1/blob/master/export.csv

Este es mi código actual:

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function

import tensorflow as tf
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from tensorflow.contrib import learn

from sklearn.pipeline import Pipeline
from sklearn import datasets, linear_model
import numpy as np


df = pd.read_csv(''/Users/zach/desktop/export.csv'')
data_ = df.drop([''ID''], axis=1)


n_classes = data_["Phylum"].nunique()

inputY = pd.get_dummies(data_[''Phylum''])

dim = 19
learning_rate = 0.000001
display_step = 50
n_hidden_1 = 500
n_hidden_2 = 500
n_hidden_3 = 500
n_hidden_4 = 500

X = tf.placeholder(tf.float32, [None, dim])


train_X = data_.iloc[:2000, :-1].as_matrix()
train_X = pd.DataFrame(data=train_X)
train_X = train_X.fillna(value=0).as_matrix()

train_Y = inputY.iloc[:2000].as_matrix()
train_Y = pd.DataFrame(data=train_Y)
train_Y = train_Y.fillna(value=0).as_matrix()

test_X = data_.iloc[2000:, :-1].as_matrix()
test_X = pd.DataFrame(data=test_X)
test_X = test_X.fillna(value=0).as_matrix()

test_Y = inputY.iloc[2000:].as_matrix()
test_Y = pd.DataFrame(data=test_Y)
test_Y = test_Y.fillna(value=0).as_matrix()

n_samples = train_Y.size
total_len = train_X.shape[0]
n_input = train_X.shape[1]
batch_size = 10


W = tf.Variable(tf.zeros([dim, n_classes]))
b = tf.Variable(tf.zeros([n_classes]))


def multilayer_perceptron(x, weights, biases):
    # Hidden layer with RELU activation
    layer_1 = tf.add(tf.matmul(x, weights[''h1'']), biases[''b1''])
    layer_1 = tf.nn.relu(layer_1)

    # Hidden layer with RELU activation
    layer_2 = tf.add(tf.matmul(layer_1, weights[''h2'']), biases[''b2''])
    layer_2 = tf.nn.relu(layer_2)

    # Hidden layer with RELU activation
    layer_3 = tf.add(tf.matmul(layer_2, weights[''h3'']), biases[''b3''])
    layer_3 = tf.nn.relu(layer_3)

    # Hidden layer with RELU activation
    layer_4 = tf.add(tf.matmul(layer_3, weights[''h4'']), biases[''b4''])
    layer_4 = tf.nn.relu(layer_4)

    # Output layer with linear activation
     out_layer = tf.matmul(layer_4, weights[''out'']) + biases[''out'']
     return out_layer

# Store layers weight & bias
weights = {
    ''h1'': tf.Variable(tf.random_normal([n_input, n_hidden_1], 0, 0.1)),
    ''h2'': tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2], 0, 0.1)),
    ''h3'': tf.Variable(tf.random_normal([n_hidden_2, n_hidden_3], 0, 0.1)),
    ''h4'': tf.Variable(tf.random_normal([n_hidden_3, n_hidden_4], 0, 0.1)),
    ''out'': tf.Variable(tf.random_normal([n_hidden_4, n_classes], 0, 0.1))
}

biases = {
    ''b1'': tf.Variable(tf.random_normal([n_hidden_1], 0, 0.1)),
    ''b2'': tf.Variable(tf.random_normal([n_hidden_2], 0, 0.1)),
    ''b3'': tf.Variable(tf.random_normal([n_hidden_3], 0, 0.1)),
    ''b4'': tf.Variable(tf.random_normal([n_hidden_4], 0, 0.1)),
    ''out'': tf.Variable(tf.random_normal([n_classes], 0, 0.1))
}

# Construct model
pred = multilayer_perceptron(X, weights, biases)

y = tf.placeholder(tf.float32, [None, n_classes])
cost = -tf.reduce_sum(y*tf.log(tf.clip_by_value(pred,1e-10,1.0)))
optimizer =     tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)
hm_epochs = 500

init = tf.initialize_all_variables()
with tf.Session() as sess:
    sess.run(init) 

    for epoch in range(hm_epochs):
        avg_cost = 0
        total_batch = int(total_len/batch_size)
        for i in range(total_batch-1):
            batch_x = train_X[i*batch_size:(i+1)*batch_size]
            batch_y = train_Y[i*batch_size:(i+1)*batch_size]

            _, c, p = sess.run([optimizer, cost, pred], feed_dict={X: batch_x,   
                                                               y: batch_y})
        avg_cost += c / total_batch

    label_value = batch_y
    estimate = p
    err = label_value-estimate

    if epoch % display_step == 0:
        print ("Epoch:", ''%04d'' % (epoch+1), "cost=", /
            "{:.9f}".format(avg_cost))
        print ("[*]----------------------------")
        for i in xrange(3):
            print ("label value:", label_value[i], /
                    "estimated value:", estimate[i])
        print ("[*]============================")

print ("Optimization Finished!")

# Test model
correct_prediction = tf.equal(tf.argmax(pred, 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}))

Mi resultado finaliza así:

Epoch: 0451 cost= 72.070914993
[*]----------------------------
label value: [0 1 0 0 0] estimated value: [ 1184.01843262 -1293.13989258    99.68536377   655.67803955  -833.19824219]
label value: [0 1 0 0 0] estimated value: [ 1183.1940918  -1273.7635498     95.80528259   656.42572021  -841.03656006]
label value: [0 1 0 0 0] estimated value: [ 1183.55383301 -1304.3470459     96.90409088   660.52886963  -838.37719727]
[*]============================
Optimization Finished!
Accuracy: 0.0

Answer 1

¡Me lo imaginé! Para mejorar la precisión, es necesario dividir el tren y probar los lotes en muestras aleatorias, de lo contrario, la red no procesará los datos necesarios y fallará. Lo he implementado reescribiendo la sección de formato de datos como tal:

df = pd.read_csv(''/Users/zach/desktop/export.csv'')
data_ = df.drop([''ID'',''Species''], axis=1)


n_classes = data_["Phylum"].nunique()

dim = 18
learning_rate = 0.0001
display_step = 10
n_hidden_1 = 2000
n_hidden_2 = 1500
n_hidden_3 = 1000
n_hidden_4 = 500

X = tf.placeholder(tf.float32, [None, dim])

train_set = data_.sample(frac=0.75) #THIS ADDITION SPLITS THE DATA RANDOMLY AND TAKE 75% FOR TRAINING
test_set = data_.loc[~data_.index.isin(train_set.index)] #THIS TAKES THE REMAINING DATA FOR TESTING

train_size = train_set.size

inputY_test = pd.get_dummies(test_set[''Phylum''])
inputY_train = pd.get_dummies(train_set[''Phylum''])

train_X = train_set.iloc[:train_size, :-1].as_matrix()
train_X = pd.DataFrame(data=train_X)
train_X = train_X.fillna(value=0).as_matrix()

train_Y = inputY_train.as_matrix()
train_Y = pd.DataFrame(data=train_Y)
train_Y = train_Y.fillna(value=0).as_matrix()

test_X = test_set.iloc[:, :-1].as_matrix()
test_X = pd.DataFrame(data=test_X)
test_X = test_X.fillna(value=0).as_matrix()

test_Y = inputY_test.as_matrix()
test_Y = pd.DataFrame(data=test_Y)
test_Y = test_Y.fillna(value=0).as_matrix()

Con estas ediciones, una simple ejecución de 50 épocas, que tomó aproximadamente 2 minutos, predijo el resultado correcto con una precisión del 91.4%