Python | Clasificar dígitos escritos a mano con Tensorflow

La clasificación de dígitos escritos a mano es el problema básico del aprendizaje automático y se puede resolver de muchas maneras. Aquí los implementaremos usando TensorFlow.
Usando un algoritmo de clasificador lineal con tf.contrib.learn 
, el clasificador lineal logra la clasificación de dígitos escritos a mano al hacer una elección basada en en el valor de una combinación lineal de las características, también conocido como valores de características y normalmente se presenta a la máquina en un vector llamado vector de características. 
Módulos requeridos:
NumPy : 

$ pip install numpy 

Matplotlib : 

$ pip install matplotlib 

Flujo de tensor : 

$ pip install tensorflow 

Pasos a seguir

Paso 1: Importación de todas las dependencias 
 

import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
 
learn = tf.contrib.learn
 
tf.logging.set_verbosity(tf.logging.ERROR)

Paso 2: Importación de conjuntos de datos usando datos MNIST 
 

mnist = learn.datasets.load_dataset('mnist')
data = mnist.train.images
labels = np.asarray(mnist.train.labels, dtype=np.int32)
test_data = mnist.test.images
test_labels = np.asarray(mnist.test.labels, dtype=np.int32)

después de este paso, se descargará un conjunto de datos de mnist. 
producción : 
 

Extracting MNIST-data/train-images-idx3-ubyte.gz
Extracting MNIST-data/train-labels-idx1-ubyte.gz
Extracting MNIST-data/t10k-images-idx3-ubyte.gz
Extracting MNIST-data/t10k-labels-idx1-ubyte.gz

Paso 3: Hacer un conjunto de datos
 

max_examples = 10000
data = data[:max_examples]
labels = labels[:max_examples]

Paso 4: Visualización del conjunto de datos usando MatplotLib 
 

def display(i):
    img = test_data[i]
    plt.title('label : {}'.format(test_labels[i]))
    plt.imshow(img.reshape((28, 28)))
     
# image in TensorFlow is 28 by 28 px
display(0)

Para mostrar datos, podemos usar esta función: mostrar (0)  
salida: 
 

Paso 5: Ajuste de datos, usando clasificador lineal 
 

feature_columns = learn.infer_real_valued_columns_from_input(data)
classifier = learn.LinearClassifier(n_classes=10,
                                    feature_columns=feature_columns)
classifier.fit(data, labels, batch_size=100, steps=1000)

Paso 6: Evaluar la precisión 
 

classifier.evaluate(test_data, test_labels)
print(classifier.evaluate(test_data, test_labels)["accuracy"])

Producción : 
 

0.9137

Paso 7: Predicción de datos 
 

prediction = classifier.predict(np.array([test_data[0]],
                                         dtype=float),
                                         as_iterable=False)
print("prediction : {}, label : {}".format(prediction,
      test_labels[0]) )

Producción : 
 

prediction : [7], label : 7

Código completo para clasificar escrito a mano 
 

# importing libraries
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf
 
learn = tf.contrib.learn
tf.logging.set_verbosity(tf.logging.ERROR)\
 
# importing dataset using MNIST
# this is how mnist is used mnist contain test and train dataset
mnist = learn.datasets.load_dataset('mnist')
data = mnist.train.images
labels = np.asarray(mnist.train.labels, dtype = np.int32)
test_data = mnist.test.images
test_labels = np.asarray(mnist.test.labels, dtype = np.int32)
 
max_examples = 10000
data = data[:max_examples]
labels = labels[:max_examples]
 
# displaying dataset using Matplotlib
def display(i):
    img = test_data[i]
    plt.title('label : {}'.format(test_labels[i]))
    plt.imshow(img.reshape((28, 28)))
     
# img in tf is 28 by 28 px
# fitting linear classifier
feature_columns = learn.infer_real_valued_columns_from_input(data)
classifier = learn.LinearClassifier(n_classes = 10,
                                    feature_columns = feature_columns)
classifier.fit(data, labels, batch_size = 100, steps = 1000)
 
# Evaluate accuracy
classifier.evaluate(test_data, test_labels)
print(classifier.evaluate(test_data, test_labels)["accuracy"])
 
prediction = classifier.predict(np.array([test_data[0]],
                                         dtype=float),
                                         as_iterable=False)
print("prediction : {}, label : {}".format(prediction,
      test_labels[0]) )
 
if prediction == test_labels[0]:
     display(0)

Uso del aprendizaje profundo con tf.keras
El aprendizaje profundo es una subparte del aprendizaje automático y la inteligencia artificial que también se conoce como red neuronal profunda, estas redes son capaces de aprender sin supervisión a partir de datos proporcionados que no están organizados ni etiquetados. hoy, implementaremos una red neuronal en TensorFlow para clasificar dígitos escritos a mano.
Módulos requeridos:
NumPy : 

$ pip install numpy 

Matplotlib : 

$ pip install matplotlib 

Flujo de tensor : 

$ pip install tensorflow 

Pasos a seguir

Paso 1: Importación de todas las dependencias 
 

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

Paso 2: Importar datos y normalizarlos 
 

mnist = tf.keras.datasets.mnist
(x_train,y_train) , (x_test,y_test) = mnist.load_data()
 
x_train = tf.keras.utils.normalize(x_train,axis=1)
x_test = tf.keras.utils.normalize(x_test,axis=1)

Paso 3: ver datos 
 

def draw(n):
    plt.imshow(n,cmap=plt.cm.binary)
    plt.show()
     
draw(x_train[0])

Paso 4: hacer una red neuronal y entrenarla 
 

#there are two types of models
#sequential is most common, why?
 
model = tf.keras.models.Sequential()
 
model.add(tf.keras.layers.Flatten(input_shape=(28, 28)))
#reshape
 
model.add(tf.keras.layers.Dense(128,activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(128,activation=tf.nn.relu))
model.add(tf.keras.layers.Dense(10,activation=tf.nn.softmax))
 
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy']
              )
model.fit(x_train,y_train,epochs=3)

Paso 5: compruebe la precisión y la pérdida del modelo 
 

val_loss,val_acc = model.evaluate(x_test,y_test)
print("loss-> ",val_loss,"\nacc-> ",val_acc)

Paso 6: predicción usando el modelo 
 

predictions=model.predict([x_test])
print('label -> ',y_test[2])
print('prediction -> ',np.argmax(predictions[2]))
 
draw(x_test[2])

guardar y probar el modelo 
 

guardando el modelo 
 

#saving the model
# .h5 or .model can be used
 
model.save('epic_num_reader.h5')

cargando el modelo guardado
 

new_model = tf.keras.models.load_model('epic_num_reader.h5')

predicción utilizando un nuevo modelo
 

predictions=new_model.predict([x_test])
 
 
print('label -> ',y_test[2])
print('prediction -> ',np.argmax(predictions[2]))
 
draw(x_test[2])