TFLearn y su instalación en Tensorflow

TFLearn se puede describir como una biblioteca de aprendizaje profundo transparente y modular creada sobre el marco Tensorflow . El objetivo principal de TFLearn es proporcionar una API de nivel superior para Tensorflow a fin de facilitar y acelerar la experimentación, sin dejar de ser totalmente compatible y transparente con ella.

Características

• TFLearn es fácil de entender y es una API de alto nivel fácil de usar para construir una estructura de redes neuronales profundas.
• A través de la alta compatibilidad incorporada de capas de redes neuronales, optimizadores, regularizadores, métricas, etc., realiza prototipos rápidos.
• Las funciones de TFLearn también se pueden usar de forma independiente, ya que todas las funciones se basan en tensores.
• Con el uso de potentes funciones auxiliares, cualquier gráfico de TensorFlow se puede entrenar fácilmente y acepta múltiples entradas, salidas y optimizadores, etc.
• TFLearn también se puede utilizar para crear magníficas visualizaciones de gráficos con detalles sobre gradientes, pesos, activaciones, etc. sin esfuerzo.
• Fácil colocación de dispositivos para utilizar múltiples CPU/GPU.

Muchas arquitecturas de red de aprendizaje profundo populares recientes, como convoluciones, redes residuales, LSTM, PReLU, BatchNorm, redes generativas, etc., son compatibles con esta API de alto nivel.

Nota: TFLearn v0.5 solo es compatible con TensorFlow versión 2.x

Instale TFLearn ejecutando este comando:

Para la versión estable:

pip install tflearn

Para la versión de última generación:

pip install git+https://github.com/tflearn/tflearn.git

Ejemplo de tflearn:

A través del ejemplo dado a continuación, se demuestra la aplicación de TFLearn Regression.

# Importing tflearn library 
import tflearn
from tflearn.layers.conv import conv_2d, max_pool_2d, input_data
from tflearn.layers.core import dropout, fully_connected
from tflearn.layers.estimator import regression
import tflearn.datasets.mnist as mnist
  
# Extracting MNIST dataset & dividing into 
# training and validation dataset
x_train,y_train,x_test,y_test = mnist.load_data(one_hot=True)
  
# Reshaping dataset from (55000,784) to (55000,28,28,1) 
# using reshape
x_train = x_train.reshape([-1, 28, 28, 1])
x_test = x_test.reshape([-1, 28, 28, 1])
  
# Defining input shape (28,28,1) for network 
network = input_data(shape=[None, 28, 28, 1], name='input')
  
# Defining conv_2d layer 
# Shape: [None,28,28,32]
network = conv_2d(network, 32, 2, activation='relu')
  
# Defining max_pool_2d layer 
# Shape: [None,14,14,32]
network = max_pool_2d(network, 2)
  
# Defining conv_2d layer 
# Shape: [None,28,28,64]
network = conv_2d(network, 64, 2, activation='relu')
  
# Defining max_pool_2d layer 
# Shape: [None,7,7,64]
network = max_pool_2d(network, 2)
  
# Defining fully connected layer 
# Shape: [None,1024]
network = fully_connected(network, 512, activation='relu')
  
# Defining dropout layer 
# Shape: [None,1024]
network = dropout(network, 0.3)
  
# Defining fully connected layer
# Here 10 represents number of classes 
# Shape: [None,10]
network = fully_connected(network, 10, activation='softmax')
  
# Defining regression layer
# Passing last fully connected layer as parameter, 
# adam as optimizer, 
# 0.001 as learning rate, categorical_crossentropy as loss 
# Shape: [None,10]
network = regression(network, optimizer='adam', 
                     learning_rate=0.001, 
                     loss='categorical_crossentropy', 
                     name='targets')
  
# Passing network made as parameter
model = tflearn.DNN(network)
  
# Fitting the model with training set:{x_train, y_train} 
# testing set:{x_test, y_test}
model.fit({'input': x_test}, {'targets': y_test}, 
          n_epoch=10, 
          snapshot_step=500, run_id='mnist',
        validation_set=({'input': x_test}, {'targets': y_test}), 
        show_metric=True)

Producción: 

Explicación:

Para implementar un clasificador usando tflearn, el primer paso es importar la biblioteca tflearn y submódulos como conv (para capas de convolución), core (para capa de abandono y completamente conectada), estimador (para aplicar regresión lineal o logística) y conjuntos de datos (para acceder a conjuntos de datos como MNIST, CIFAR10, etc.)

Usando load_data, el conjunto de datos MNIST se extrae y se divide en un conjunto de entrenamiento y validación con una entrada x que tiene una forma (muestras, 784). Ahora, para usar la entrada x para el entrenamiento, la remodelamos de (muestras, 784) a (muestras, 28,28,1) usando .reshape (NewShape). Después de esto, definimos la misma forma nueva para la red. Ahora, para definir el modelo de red, apilamos algunas capas convolution2d y max_pooling2d juntas, seguidas de abandono apilado y capas completamente conectadas.