TensorFlow: API de bajo y alto nivel

En este artículo, quiero proporcionar un tutorial sobre la implementación de una red neuronal simple utilizando API de niveles inferiores y superiores. Mi breve tutorial está destinado a personas que conocen Python u otro lenguaje de programación y tienen una comprensión básica del aprendizaje profundo .

API de bajo nivel

Preparé funciones auxiliares para crear pesos para el modelo. Utilicé un inicializador normal truncado con media 0 y desviación estándar 0.1 para peso y cero constante para sesgo para inicializar valores.

def weight_variable(shape):
    shape = tf.TensorShape(shape)
    initial_values = tf.truncated_normal(shape, stddev=0.1)
    
    return tf.Variable(initial_values)
def bias_variable(shape):
    initial_values = tf.zeros(tf.TensorShape(shape))
    
    return tf.Variable(initial_values)

# Define placeholders
X = tf.placeholder(tf.float32, shape=[None, 4])
y = tf.placeholder(tf.int32, shape=[None, 3])
# Define variables
w1 = weight_variable([X_input.shape[1], 2])
b1 = bias_variable([2])
w2 = weight_variable([2, 3])
b2 = bias_variable([3])

# Define network
# Hidden layer
z1 = tf.add(tf.matmul(X, w1), b1)
a1 = tf.nn.relu(z1)
# Output layer
z2 = tf.add(tf.matmul(a1, w2), b2)
y_pred = tf.nn.softmax(z2)
y_one_hot = tf.one_hot(y, 3)
# Define loss function
loss = tf.losses.softmax_cross_entropy(y, y_pred, reduction=tf.losses.Reduction.MEAN)
# Define optimizer
optimizer = tf.train.AdamOptimizer(0.01).minimize(loss)
# Metric
accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.argmax(y, axis=1), tf.argmax(y_pred, axis=1)), tf.float32))

for _ in range(n_epochs):
    sess.run(optimizer, feed_dict={X: X_train, y: y_train})

API de alto nivel (usando Estimadores)

Agregué todos los detalles en los comentarios. Esta es la misma red que la anterior.

def model_fn(features, labels, mode):
    X = features['x']
    
    # Define weights initializer
    kernel_initializer = tf.initializers.truncated_normal(stddev=0.1)
 
    # Define network  
    hidden = tf.layers.dense(
        X, 2, activation=tf.nn.relu, 
        kernel_initializer=kernel_initializer)
    
    logits = tf.layers.dense(
        hidden, 3, 
        kernel_initializer=kernel_initializer)
    # Define dictionary with predicted class 
    # and probabilities for each class
    predictions = {
        'class': tf.argmax(logits, axis=1),
        'probabilities': tf.nn.softmax(logits)
    }
    # If we are on prediction mode, 
    # we return estimator specification
    # with predictions
    if mode == tf.estimator.ModeKeys.PREDICT:
        return tf.estimator.EstimatorSpec(
            mode, predictions=predictions)
    
    onehot_labels = tf.one_hot(labels, depth=3)       
    loss = tf.losses.softmax_cross_entropy(onehot_labels, logits)
    # If we are on training mode, 
    # we need to do few things.
    if mode == tf.estimator.ModeKeys.TRAIN:
        # Create optimizer
        optimizer = tf.train.AdamOptimizer(learning_rate=0.01)
        
        # Define training operation (minimize loss function)        
        train_op = optimizer.minimize(
            loss, global_step=tf.train.get_global_step())
        # Return estimator specification 
        # with loss and training operations  
        return tf.estimator.EstimatorSpec(
            mode, loss=loss, train_op=train_op)
    
    # If we are on evaluation mode,
    # we need to define metrics operations
    eval_metric_ops = {
        'accuracy': tf.metrics.accuracy(
            labels, predictions['class'])
    }
    # Return estimator specification 
    # with loss and metrics operations   
    return tf.estimator.EstimatorSpec(
        mode, loss=loss, eval_metric_ops=eval_metric_ops)

classifier = tf.estimator.Estimator(model_fn)

input_fn = tf.estimator.inputs.numpy_input_fn(
    {'x': X_train}
    batch_size=200, 
    num_epochs=100, 
    shuffle=True)

classifier.train(input_fn)

TensorFlow ofrece una variedad de modelos predefinidos. Para este ejemplo, puede usar el clasificador de redes neuronales profundas.

feature_columns = [
    tf.feature_column.numeric_column("x", shape=[4])]
classifier = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[2],
    n_classes=3,
    model_dir="/tmp/iris_model")
classifier.train(input_fn=input_fn)

Siéntase libre de comentar o dar algunos comentarios.