<jupyter_start><jupyter_text>Redes neuronales convolucionales> **<NAME>** > Google Dev Expert en ML, 2020.>> _Redes:_> - GitHub - [RodolfoFerro](https://github.com/RodolfoFerro)> - Twitter - [@FerroRodolfo](https://twitter.com/FerroRodolfo)> - Instagram - [@rodo_ferro](https://instagram.com/rodo_ferro) Contenidos **Sección V**1. **Código:** El dataset de modas2. **Código:** Preparación de datos3. **Código:** Creación del modelo4. **Código:** Entrenamiento del modelo5. **Código:** Evaluación del modelo6. **Código:** Predicción  **Sección V**  El dataset de modasComencemos importando TensorFlow.<jupyter_code>import tensorflow as tf
print(tf.__version__)<jupyter_output><empty_output><jupyter_text>Los datos de Fashion MNIST están disponibles directamente en la API de conjuntos de datos de `tf.keras`. Los cargas así:<jupyter_code>fashion_mnist = tf.keras.datasets.fashion_mnist<jupyter_output><empty_output><jupyter_text>Llamar a `load_data` en este objeto nos dará dos conjuntos con los valores de entrenamiento y prueba para los gráficos que contienen las prendas y sus etiquetas.<jupyter_code>(training_images, training_labels), (test_images, test_labels) = fashion_mnist.load_data()<jupyter_output><empty_output><jupyter_text>¿Cómo se ven estos valores?Imprimamos una imagen de entrenamiento y una etiqueta de entrenamiento para ver.<jupyter_code>import numpy as np
import matplotlib.pyplot as plt
np.set_printoptions(linewidth=200)


# Set index of image to be seen
img_index = 0

# Plot image
plt.imshow(training_images[img_index], cmap='gray')
plt.axis(False)

print("Label:", training_labels[img_index])
print("Matrix:", training_images[img_index])<jupyter_output><empty_output><jupyter_text>Preparación de los datosNotarás que todos los valores están entre 0 y 255. Si estamos entrenando una red neuronal, por varias razones es más fácil si transformamos los valores para tratar todos con valores entre 0 y 1. Este proceso se llama **normalización**.Además, para este proceso añadiremos la expansión de dimensiones para poder alimentar a la red.<jupyter_code>training_images = training_images.reshape(60000, 28, 28, 1)
training_images = training_images / 255.0

test_images = test_images.reshape(10000, 28, 28, 1)
test_images = test_images/255.0<jupyter_output><empty_output><jupyter_text>Creación del modeloEn el cuaderno anterior vimos cómo hacer el reconocimiento de moda usando una red neuronal profunda (DNN) que contiene tres capas: la capa de entrada (en la forma de los datos), la capa de salida (en la forma de la salida deseada) y una capa oculta. Idealmente experimentamos con el impacto de diferentes tamaños de capa oculta, número de épocas de entrenamiento, etc., para ver estos resultados reflejados en la precisión final.<jupyter_code>model = tf.keras.models.Sequential([
            tf.keras.layers.Flatten(), 
            tf.keras.layers.Dense(128, activation=tf.nn.relu), 
            tf.keras.layers.Dense(10, activation=tf.nn.softmax)
        ])<jupyter_output><empty_output><jupyter_text>Tu precisión es probablemente de aproximadamente el 89% en el entrenamiento y el 87% en la validación, que no está mal... ¿Pero cómo podemos mejorarlo? Una forma es usar capas convolucionales en la red.**Estas operaciones reducen el contenido de la imagen para centrarse en detalles específicos y distintos.**Si alguna vez has procesado imágenes con un filtro (como este: https://en.wikipedia.org/wiki/Kernel_(image_processing)), las convoluciones te resultarán muy familiares.En resumen, pasaremos una matriz (generalmente 3x3 o 5x5) sobre la imagen. Al cambiar los píxeles subyacentes según la fórmula dentro de esa matriz, podemos hacer cosas como la detección de bordes.Esto es perfecto para la visión por computadora, porque a menudo son las características que pueden resaltarse de esta manera las que distinguen un elemento de otro, y la cantidad de información necesaria es mucho menor porque sólo entrenaremos la red sobre las características resaltadas.Ese es el concepto de redes neuronales convolucionales. Agreguemos algunas capas para hacer la convolución antes de tener las capas densas, así la información que va a las capas densas está más enfocada y posiblemente más precisa.<jupyter_code>model = tf.keras.models.Sequential([
    tf.keras.layers.Conv2D(64, (3,3), activation='relu', input_shape=(28, 28, 1)),
    tf.keras.layers.MaxPooling2D(2, 2),
    tf.keras.layers.Conv2D(64, (3,3), activation='relu'),
    tf.keras.layers.MaxPooling2D(2,2),
    tf.keras.layers.Flatten(),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])<jupyter_output><empty_output><jupyter_text>Entrenamiento del modelo<jupyter_code>model.compile(
    optimizer=tf.optimizers.Adam(),
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)
model.fit(training_images, training_labels, epochs=5)<jupyter_output><empty_output><jupyter_text>Evaluación del modelo<jupyter_code>model.evaluate(test_images, test_labels)<jupyter_output><empty_output><jupyter_text>Predicción<jupyter_code>test_index = 30

plt.imshow(np.squeeze(test_images[test_index]), cmap='gray')
plt.axis(False)

print("Label:", test_labels[test_index])
prediction = model.predict(np.expand_dims(test_images[test_index], axis=0))
print("Prediction:", np.argmax(prediction))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.0957983193277311, 'fraction_numerical': 0.01699346405228758, 'mean_word_length': 6.15086782376502, 'pattern_counts': {'":': 0, '<': 42, '<?xml version=': 0, '>': 49, 'https://': 4, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '10', 'dir': 'jupyter-structured-clean-dedup', 'id': '223668', 'license': 'MIT', 'n_tokens_mistral': 1893, 'n_tokens_neox': 1806, 'n_words': 512, 'path': 'notebooks/04-Redes_neuronales_convolucionales.ipynb', 'repo_name': 'RodolfoFerro/cimps20', 'size': '5362'}