REPÚBLICA BOLIVARIANA DE VENEZUELA

VICERRECTORADO ACADÉMICO
FACULTAD DE INGENIERÍA
ESCUELA DE INGENIERÍA DE SISTEMAS
SAN JOAQUÍN DE TURMERO ESTADO ARAGUA

Redes Neuronales Densas

Profesor:                                     Participante:
José Ceballos                                     Beatriz Paredes C.I: 27.864.010 

Noviembre 2022
 Índice
Introducción 2
Desarrollo 4
Conclusión 9
Referencias 10
 Introducción

Las redes neuronales funcionan exactamente igual a cómo funcionan

las neuronas en nuestro cerebro a nivel conceptual. Las neuronas artificiales
son un modelo de aprendizaje automático, las cuales consisten en un
conjunto de unidades, conectadas entre sí para transmitirse señales

La siguiente red neuronal es de clasificación ya que en resumen lo

que ella hará es dar un resultado entre 10 números fijos. Es una red neuronal
con capas densas ya que cada neurona de una capa se conecta con todas
las neuronas de la siguiente capa y también es le puede clasificar como una
red profunda ya que esta usando mas de una capa oculta y por ultimo se le
agrega aprendizaje supervisado porque estamos usando imágenes conocido
también como lotes de entrenamiento

Las redes neuronales se separan en tres tipos de capas de las que tenemos:

La primera capa recibe como entrada los datos reales que alimentan a
la red neuronal.  Es por eso por lo que la primera capa se conoce como capa
de entrada. La salida de la última capa es el resultado visible de la red, por lo
que la última capa se conoce como la capa de salida. Las capas que se
sitúan entre la capa de entrada y la capa de salida se conocen como capas
ocultas las cuales no reciben ni suministran información al entorno
(procesamiento interno de la red)
 Desarrollo

from __future__ import absolute_import, division, print_function,

unicode_literals

import tensorflow as tf
import tensorflow_datasets as tfds

import math
import numpy as np
import matplotlib.pyplot as plt
import logging
logger = tf.get_logger()

logger.setLevel(logging.ERROR)

dataset, metadata = tfds.load('mnist', as_supervised=True, with_info=True)

train_dataset, test_dataset = dataset['train'], dataset['test']

class_names = [
    'Cero', 'Uno', 'Dos', 'Tres', 'Cuatro', 'Cinco', 'Seis',
    'Siete', 'Ocho', 'Nueve'
]

num_train_examples = metadata.splits['train'].num_examples
num_test_examples = metadata.splits['test'].num_examples

#Normalizar: Numeros de 0 a 255, que sean de 0 a 1

def normalize(images, labels):
    images = tf.cast(images, tf.float32)
    images /= 255
    return images, labels

train_dataset = train_dataset.map(normalize)
test_dataset = test_dataset.map(normalize)

#Estructura de la red
model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28,28,1)),
    tf.keras.layers.Dense(64, activation=tf.nn.relu),
    tf.keras.layers.Dense(64, activation=tf.nn.relu),
    tf.keras.layers.Dense(10, activation=tf.nn.softmax) #para clasificacion
])

#Indicar las funciones a utilizar

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)
#Aprendizaje por lotes de 32 cada lote
BATCHSIZE = 32
train_dataset =
train_dataset.repeat().shuffle(num_train_examples).batch(BATCHSIZE)
test_dataset = test_dataset.batch(BATCHSIZE)

#Realizar el aprendizaje
model.fit(
    train_dataset, epochs=5,
    steps_per_epoch=math.ceil(num_train_examples/BATCHSIZE) #No sera
necesario pronto
)

#Evaluar nuestro modelo ya entrenado, contra el dataset de pruebas

test_loss, test_accuracy = model.evaluate(
    test_dataset, steps=math.ceil(num_test_examples/32)
)

print("Resultado en las pruebas: ", test_accuracy)

for test_images, test_labels in test_dataset.take(1):

    test_images = test_images.numpy()
    test_labels = test_labels.numpy()
    predictions = model.predict(test_images)

def plot_image(i, predictions_array, true_labels, images):

    predictions_array, true_label, img = predictions_array[i], true_labels[i],
images[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])

    plt.imshow(img[...,0], cmap=plt.cm.binary)

    predicted_label = np.argmax(predictions_array)
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'

    plt.xlabel("Prediccion: {}".format(class_names[predicted_label]),
color=color)

def plot_value_array(i, predictions_array, true_label):

    predictions_array, true_label = predictions_array[i], true_label[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#888888")
    plt.ylim([0,1])
    predicted_label = np.argmax(predictions_array)

    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

numrows=5
numcols=3
numimages = numrows*numcols

plt.figure(figsize=(2*2*numcols, 2*numrows))
for i in range(numimages):
    plt.subplot(numrows, 2*numcols, 2*i+1)
    plot_image(i, predictions, test_labels, test_images)
    plt.subplot(numrows, 2*numcols, 2*i+2)
    plot_value_array(i, predictions, test_labels)

plt.show()
 Conclusión

En la red neuronal anterior mostramos que esta es capaz de leer

números. Dándole 784 neuronas de entrada, teniendo dos capas ocultas con
un total de 64 neuronas y por último tendremos 10 neuronas en su capa de
salida representando los números del 0 al 9.

Para comprobar las respuestas de nuestra red neuronal se usó la

función de costo que lo que hace es revisar las respuestas de la red neuronal
y las respuestas que tuvo que haber dado. Se va optimizando con más
ejemplos o variables para que este pueda dar una respuesta acertada ya que
con esto las capas abstraen cada vez más la información de la variable o
imagen ya que algunos caminos se especializan en detectar algunas curvas,
otros algunas líneas y en conjunto si las líneas y curvas están en el lugar
correcto, los pesos y umbrales conectados a dicho numero se activaran y
arrojaran esa neurona de salida
 Referencias

Garcia-Olalla, O. (2019). Redes Neuronales artificiales: Qué son y cómo se

entrenan Disponible en: https://www.xeridia.com/blog/redes-neuronales-
artificiales-que-son-y-como-se-entrenan-parte-i. Consultado en: octubre 19,
2022.

Fernández A. Cómo programar una red neuronal desde 0 en Python,

Disponible en: https://anderfernandez.com/blog/como-programar-una-red-
neuronal-desde-0-en-python/#:~:text=Para%20crear%20una%20red
%20neuronal,estructura%20de%20nuestra%20red%20neuronal. Consultado
en: octubre 19, 2022

Ramis M. (1943). Neurona artificial. Estados unidos, Disponible en:

https://proyectoidis.org/neurona-artificial/. Consultado en: octubre 19, 2022