Reconocedor de dígitos: red neuronal artificial (ANN)

Conclusión

en el artículo les he dado información y códigos sobre cómo hacer una Red Neuronal Artificial
(ANN) con código fuente . Estaría haciendo modelos más emocionantes para ustedes, así que
manténganse conectados.

https://becominghuman.ai/digit-recogniser-artificial-neural-network-ann-f8ca23426478

Reconocedor de dígitos: red neuronal artificial (ANN)

Usando la red neuronal artificial (ANN) para hacer un modelo de abandono, crearemos un
modelo que predice un dígito escrito a mano. (con código fuente)

Como en el artículo anterior, les he dado una introducción a la Red Neural Artificial (ANN),
ahora les diré cómo hacer un modelo ANN básico en este artículo con algunas líneas
de códigos.

En este artículo, tomaremos la entrada de dígitos escritos a mano y predeciremos el número

utilizando la red neuronal artificial (ANN).

Si desea obtener más información sobre las redes neuronales artificiales (ANN) , siga
este enlace :

¿Qué son las Redes Neuronales Artificiales (RNA)?

Introducción a las redes neuronales artificiales

volversehumano.ai
Importación de las bibliotecas

Ahora importaremos pandas, NumPy, Keras, Matplotlib y Tensorflow como se muestra a

continuación. Si su sistema no tiene estas bibliotecas instaladas, puede obtenerlas usando
el comando pip.
importar ssl
ssl._create_default_https_context = ssl._create_unverified_context

importar tensorflow como tf

de tensorflow importar keras
importar matplotlib.pyplot como plt
importar numpy como np

conjunto de datos

Cargando el conjunto de datos

Keras ha proporcionado los datos y podemos importarlos de esta manera.

Aquí hemos importado el tren y el conjunto de datos de prueba de Keras

(x_train, y_train) , (x_test, y_test) =
keras.datasets.mnist.load_data()

forma del conjunto de datos

Ahora, veremos la forma del tren y los datos de prueba para saber cuántas imágenes
entrenaremos en el modelo.
x_train.shape

x_test.shape

El conjunto de datos contiene 60 000 imágenes en la variable de tren y 10 000 imágenes en la

variable de prueba

Trazado

Debido a que los datos están en una matriz numpy, no podremos ver ninguna imagen porque
es una matriz, por lo que tendremos que trazar la imagen en matplotlib con este comando.
plt.matshow(x_train[0])
Escalada

ya que los valores en la matriz varían de 0 a 255, donde 0 significa negro y 255 significa blanco,
por lo que si tomamos estos datos en nuestro modelo, esto afectaría el entrenamiento de
nuestro modelo, por lo que para superar este problema, escalaremos nuestro conjunto de
datos y aquí dividiremos por 255 para que podamos obtener un rango de 0 a 1
x_train=x_train/255
x_test=x_test/255

aplanado

Ahora estamos aplanando nuestro tren y nuestro conjunto de datos de prueba.

x_tren_aplanado = x_tren.reforma(len(x_tren), 28*28)
x_test_flattened = x_test.reshape(len(x_test), 28*28)

Modelo

Hacer un modelo ANN es mucho más difícil que hacer modelos de aprendizaje automático.

modelo = keras.Sequential([
keras.layers.Dense(100,activation='relu'),
keras.layers.Dense(10,activación='sigmoide')
])

modelo.compilar(optimizador='adam',
loss='parse_categorical_crossentropy',
métricas=['precisión'])

model.fit(x_train_flattened, y_train, epochs=5)

Primero, estoy comenzando un modelo secuencial con tensorflow keras. El segundo paso es

agregar las capas ocultas al modelo. Las capas se agregan así: aquí, en este modelo, hay dos
capas ocultas y una capa para compilar las capas anteriores.
  En la primera capa oculta, estoy usando 100 neuronas y una función
de activación relu. Explicaré estos conceptos en un artículo posterior, así que
recuérdalos por ahora.

 La segunda capa oculta es similar a la anterior, y estoy usando 10 neuronas (porque

tenemos números del 0 al 9, por lo que solo 10 números pueden ser nuestra salida,
por eso estamos usando 10 neuronas en la última capa) y
la activación función sigmoide.

Aquí viene el compilador; ahora debemos compilar las tres capas en el modelo. Estoy usando

la función de optimizador como Adam, la pérdida como entropía cruzada categórica escasa y
las métricas como precisión.

Ahora debemos usar el comando de ajuste para ajustar todo el conjunto de datos en el

modelo.

el tamaño del lote significa el número de ejemplos en una iteración.

epochs significa el número de pases de todo el conjunto de datos de entrenamiento que ha

completado el algoritmo de aprendizaje automático.

predecir

ahora aquí estoy haciendo una variable de predicción que predecirá el conjunto de datos de
prueba en el modelo entrenado
predictions = model.predict(x_test_flattened)

Valor único

podemos usar esta línea de código para predecir un solo valor. aquí puede ver que claramente
el número es 1 y nuestro modelo entrenado también predice 1
plt.matshow(x_test[2])
np.argmax(predicciones[2])
también podemos hacer una función para predecir un solo valor
def predecir(i):
plt.matshow(x_test[i])
imprimir(np.argmax(predicciones[i]))

predecir (1)

Exactitud

Ahora veremos la precisión de nuestro modelo . Nuestro modelo tiene una precisión

del 97 por ciento , lo que significa que predijo correctamente 97 valores de 100 posibles .

model.evaluate(x_test_flattened,y_test)
código fuente

puedes ir a ver el enlace para el código completo

códigos/digit_recon(ANN).ipynb en principal · aviralb13/códigos

Contribuya al desarrollo de aviralb13/codes creando una cuenta en GitHub.

github.com

Conclusión

en el artículo les he dado información y códigos sobre cómo hacer una Red Neuronal Artificial
(ANN) con código fuente. Estaría haciendo modelos más emocionantes para ustedes, así que
manténganse conectados.

importar ssl

ssl._create_default_https_context = ssl._create_unverified_context

LÍNEAS DE PROGRAMA

importar tensorflow como tf

de tensorflow importar keras

importar matplotlib.pyplot como plt

importar numpy como np

(x_tren, y_tren) , (x_prueba, y_prueba) = keras.datasets.mnist.load_data()

x_tren.forma

x_test.shape

plt.matshow(x_tren[0])

x_tren=x_tren/255

x_prueba=x_prueba/255

x_tren_aplanado = x_tren.reforma(len(x_tren), 28*28)

x_test_flattened = x_test.reshape(len(x_test), 28*28)

modelo = keras.Sequential([

keras.layers.Dense(100,activation='relu'),

keras.layers.Dense(10,activación='sigmoide')

])

modelo.compilar(optimizador='adam',

loss='parse_categorical_crossentropy',

métricas=['precisión'])

model.fit(x_train_flattened, y_train, epochs=5)

predicciones = model.predict(x_test_flattened)

plt.matshow(x_test[2])

np.argmax(predicciones[2])

def predecir(i):

plt.matshow(x_test[i])

imprimir(np.argmax(predicciones[i]))

predecir (1)

modelo.evaluar(x_test_flattened,y_test)