Creando nuestra primera red convolucional

Clase 4 de 25 • Curso de Redes Neuronales Convolucionales con Python y Keras

GABRIEL OMAR TARAPUES RODRIGUEZ

student•

Compas, me esta saliendo el siguiente error, alguien me podria ayudar....de antemano muchas Gracias.

GABRIEL OMAR TARAPUES RODRIGUEZ

student•

al final del trace, sale lo siguiente:

Alarcon7a

student•

excelente hallazgo

Tomas Dale

student•

No tenia claro las transformaciones,

los valores de los datos son de 60,000 imagenes en 28 x 28 en las celdas los valores son de 0 a 255 y los transforma a modo que sean decimales, el mayor llega a 1 porque asi maneja mejor el proceso

Luego en los labels, etiquetas, son 60,000 en ellas tienes valores de 0 a 9, por el tipo de ropa, y lo transforma para que sea asi, el numero 2 pasa a ser 0,0,1,0,0,0,0,0,0,0 el numero 5 para a ser 0,0,0,0,0,1,0,0,0,0

Alarcon7a

student•

Exactamente!!

Juan Jose Sepulveda Calderon

student•

En la clase de: Una imagen es una matriz del Curso de Álgebra Lineal Aplicada para Machine Learning vemos como no es tan importante los valores de la matriz, lo que es importante es la relación entre ellos, por lo que si divides la matriz por una escalar sigues teniendo la misma imagen.

Carlos Isael Ramírez González

student•

Tengo entendido que bajo el contexto de redes neuronales es mas conveniente que solo haya entre 0 y 1, en el mismo curso hacemos lo mismo para poder hacer una descomposicion SVD (en el de algebra lineal aplicada a machine learning) y tenemos que dividir los numeros entre 255

Juan Marmili

student•

Si les sale el error: NameError: name 'Flatten' is not defined Tienen que importar antes: from tensorflow.keras.layers import Flatten

Juan David Leon Barrera

student•

Hola,

¿Cual seria el curso anterior a este? es que literalmente no entendi nada de lo que hacia

Brayan Alexis Lechon Andrango

student•

Hola 👋🏻

El curso se llama: Curso de Fundamentos de Redes Neuronales con Python y Keras

Jhonntan Andres Castaño Rojas

student•

estoy usando mi gpu local por primera vez para el curso si alguien tambien escribame por favor para que nos ayudemos

Eduard Giraldo Martínez

student•

Hola, Jhonatan. 😁

¿Pudiste activar correctamente CUDA?

Fue un poco tedioso para mí, pero se pudo activar, me gustaría aprender un poco más de cómo sacarle más provecho

Jhon Freddy Tavera Blandon

student•

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))

# Añadir capas totalmente conectadas en la parte superior
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

750/750 ━━━━━━━━━━━━━━━━━━━━ 6s 4ms/step - accuracy: 0.8375 - loss: 0.5164 - val_accuracy: 0.9816 - val_loss: 0.0647
Epoch 2/5
750/750 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.9792 - loss: 0.0644 - val_accuracy: 0.9835 - val_loss: 0.0529
Epoch 3/5
750/750 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.9873 - loss: 0.0407 - val_accuracy: 0.9868 - val_loss: 0.0446
Epoch 4/5
750/750 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.9908 - loss: 0.0307 - val_accuracy: 0.9848 - val_loss: 0.0522
Epoch 5/5
750/750 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.9935 - loss: 0.0230 - val_accuracy: 0.9869 - val_loss: 0.0474
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9867 - loss: 0.0439
Accuracy en el conjunto de prueba: 0.989300012588501
Model: "sequential_9"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ conv2d_13 (Conv2D)              │ (None, 26, 26, 32)     │           320 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_7 (MaxPooling2D)  │ (None, 13, 13, 32)     │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_14 (Conv2D)              │ (None, 11, 11, 64)     │        18,496 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_8 (MaxPooling2D)  │ (None, 5, 5, 64)       │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_15 (Conv2D)              │ (None, 3, 3, 64)       │        36,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten_3 (Flatten)             │ (None, 576)            │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_6 (Dense)                 │ (None, 64)             │        36,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_7 (Dense)                 │ (None, 10)             │           650 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
 Total params: 279,968 (1.07 MB)
 Trainable params: 93,322 (364.54 KB)
 Non-trainable params: 0 (0.00 B)
 Optimizer params: 186,646 (729.09 KB)

camilo franco

student•

Hay nuevas opcioens en kaggle si alguien sabe como se usan o cuales se deben elegir seria de gran ayuda. GRACIAS!!

Cristian Tinipuclla

student•

yo lo tengo igual y me va igual que al profe, está bien tu configuración c:

Diego Sanz

student•

Buenos, ¿cómo están?

Observando el summary de la Red Neuronal Convolucional generada, les quería consultar ¿Por qué no se cuentan los parámetros para las capas de Max Pooling, Dropout y Flatten? Mientras que solo se cuentan los parámetros para las convolucionales y densas.

Muchas gracias, saludos!

Alarcon7a

student•

Hola, estos temas se ven a lo largo del curso, menos los de dropout y regularizers que se ven en el curso de fundamentos de redes neuronales con Python y keras.

Tomas Dale

student•

Me hubiera gustado que hubiera explicado para que servia kernel_size, padding

David Zambrano

student•

el kernel size se refiere al tamaño del filtro, que como es cuadrado solo se indica una de las dimensiones. y el padding es el tamaño del marco (en pixeles adicionales) que se agrega a la imagen, de tal forma que los pixeles de las esquinas y bordes de la imagen original, no se pierdan del todo con la convolución. Normalmente se usan dos tipos de padding: same y valid. En el 'same' lo que sucede es que el resultado de la convoluciòn conserva las dimensiones de la imagen original.

Vladimir Marcos Vega

student•

consulta, porqué los px van de 0 255 ?

ASDRUBAL LOPEZ CHAU

student•

Hola @Vladimir. El modelo de color RGB consiste en representar cada pixel con tres valores. Uno para el Rojo (R, Red), otro para el Verde (G, Green) y otro más para el Azul (B, Blue). Cada valor está en el rango de 0 a 255. Un valor cero significa intensidad NULA del color correspondiente. Un valor 255 se interpreta como la máxima intensidad del color. Cada combinación corresponde a una combinación única de valores. El color negro es (0, 0, 0), el blanco es (255, 255, 255).

marcelocallao60

student•

Si no les permite abrir ni en kaggle ni en visual studio code, usen jupyter lab , seleccionen Python (ven-TF) y podra correr sin problema alguno

Ricardo Cruz

student•

✅Aquí les traigo una forma grafica para que lo vean mejor.

Cristian Sebastian Suarez Catama

student•

Alguien que pueda ayuda, como hago para activar el popup que se ve en la imagen, porfa

Iván Roberto Rivas Celeita

student•

Este es el código que me funciono porque ya no hay soporte de 
keras en tensorflow:

import numpy as np
import tensorflow as tf
import keras
from keras import layers, Sequential
#from tensorflow import keras
import tf_keras as tk
from tf_keras.datasets import fashion_mnist
from tf_keras.layers import Conv2D, Dropout, MaxPooling2D, Flatten, Dense
#from tensorflow.keras.layers import Conv2D, Dropout, MaxPooling2D, Flatten, Dense
import matplotlib.pyplot as plt

(train_images, train_labels),(test_images, test_labels)=fashion_mnist.load_data()

train_images.shape

#Escalar los valores (255 porque va hasta 255 px)
train_images = train_images.astype('float32')/255
test_images = test_images.astype('float32')/255

train_images = train_images.reshape(train_images.shape[0],28,28,1)
test_images = test_images.reshape(test_images.shape[0],28,28,1)

train_labels[2]

train_labels = tk.utils.to_categorical(train_labels,10)
test_labels = tk.utils.to_categorical(test_labels,10)

##Modelo de datos

model = keras.Sequential()
model.add(keras.layers.Conv2D(filters=64, kernel_size=2,padding='same', activation='relu', input_shape=(28,28,1)))
model.add(keras.layers.MaxPooling2D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(keras.layers.Conv2D(filters=32, kernel_size=2,padding='same', activation='relu'))
model.add(keras.layers.MaxPooling2D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(256,activation='relu'))
model.add(keras.layers.Dropout(0.5))
model.add(keras.layers.Dense(10,activation='softmax'))
model.summary()

Mario Alexander Vargas Celis

student•

Crear tu primera **red convolucional** (CNN) en PyTorch es un gran paso para aprender sobre el uso de las CNN en la visión por computadora. A continuación te mostraré cómo se puede construir una CNN simple para la clasificación de imágenes usando PyTorch.

Este ejemplo usará el conjunto de datos **CIFAR-10**, que es un conjunto estándar para la clasificación de imágenes en 10 categorías (aviones, autos, gatos, etc.).

### 1. Preparar el entorno

Primero, asegúrate de tener las bibliotecas necesarias instaladas. Si no las tienes, puedes instalarlas utilizando pip:


pip install torch torchvision

### 2. Importar las bibliotecas necesarias


import torch

import torch.nn as nn

import torch.optim as optim

import torch.nn.functional as F

from torchvision import datasets, transforms

from torch.utils.data import DataLoader

### 3. Cargar el conjunto de datos (CIFAR-10)

Aquí usamos torchvision para cargar el conjunto de datos CIFAR-10, que se dividirá en conjuntos de entrenamiento y prueba, y se aplicarán algunas transformaciones como la normalización y el redimensionamiento.


\# Definir transformaciones para normalizar y convertir a tensor

transform = transforms.Compose(\[

&#x20;   transforms.ToTensor(),

&#x20;   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))

])



\# Descargar el conjunto de datos CIFAR-10

train\_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)

test\_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)



\# Cargar los datos en mini-lotes

train\_loader = DataLoader(train\_dataset, batch\_size=32, shuffle=True)

test\_loader = DataLoader(test\_dataset, batch\_size=32, shuffle=False)

### 4. Definir la arquitectura de la red convolucional

A continuación, definimos nuestra primera red convolucional simple, que incluye varias capas convolucionales, capas de activación ReLU, max pooling y capas completamente conectadas.


class SimpleCNN(nn.Module):

&#x20;   def \_\_init\_\_(self):

&#x20;       super(SimpleCNN, self).\_\_init\_\_()

&#x20;       \# Primera capa convolucional: Conv2d(input\_channels, output\_channels, kernel\_size)

&#x20;       self.conv1 = nn.Conv2d(3, 32, kernel\_size=3, padding=1)

&#x20;       self.conv2 = nn.Conv2d(32, 64, kernel\_size=3, padding=1)

&#x20;      &#x20;

&#x20;       \# Max Pooling layer

&#x20;       self.pool = nn.MaxPool2d(kernel\_size=2, stride=2)

&#x20;      &#x20;

&#x20;       \# Fully connected layers

&#x20;       self.fc1 = nn.Linear(64 \* 8 \* 8, 512)  # CIFAR-10 images are 32x32, so after pooling, they're 8x8

&#x20;       self.fc2 = nn.Linear(512, 10)  # 10 output classes (for CIFAR-10)

&#x20;  &#x20;

&#x20;   def forward(self, x):

&#x20;       \# Aplicar la primera capa convolucional seguida de ReLU y max pooling

&#x20;       x = self.pool(F.relu(self.conv1(x)))

&#x20;      &#x20;

&#x20;       \# Segunda capa convolucional seguida de ReLU y max pooling

&#x20;       x = self.pool(F.relu(self.conv2(x)))

&#x20;      &#x20;

&#x20;       \# Aplanar los datos para conectarlos a las capas completamente conectadas

&#x20;       x = x.view(-1, 64 \* 8 \* 8)

&#x20;      &#x20;

&#x20;       \# Capa completamente conectada seguida de ReLU

&#x20;       x = F.relu(self.fc1(x))

&#x20;      &#x20;

&#x20;       \# Capa de salida (no necesitamos una activación aquí, ya que usaremos CrossEntropyLoss más adelante)

&#x20;       x = self.fc2(x)

&#x20;       return x

### 5. Definir el criterio de pérdida y el optimizador

Usaremos la **pérdida de entropía cruzada** (CrossEntropyLoss) para la clasificación, y el optimizador **Adam**, que es eficiente para entrenar redes neuronales.


model = SimpleCNN()



\# Criterio de pérdida y optimizador

criterion = nn.CrossEntropyLoss()

optimizer = optim.Adam(model.parameters(), lr=0.001)

### 6. Entrenar el modelo

Ahora, escribimos el bucle de entrenamiento para optimizar el modelo sobre el conjunto de datos de entrenamiento.


\# Entrenamiento

num\_epochs = 10  # Número de épocas de entrenamiento



for epoch in range(num\_epochs):

&#x20;   running\_loss = 0.0

&#x20;   for images, labels in train\_loader:

&#x20;       \# Forward pass

&#x20;       outputs = model(images)

&#x20;       loss = criterion(outputs, labels)

&#x20;      &#x20;

&#x20;       \# Backward pass y optimización

&#x20;       optimizer.zero\_grad()

&#x20;       loss.backward()

&#x20;       optimizer.step()

&#x20;      &#x20;

&#x20;       running\_loss += loss.item()

&#x20;  &#x20;

&#x20;   print(f'Epoch \[{epoch + 1}/{num\_epochs}], Loss: {running\_loss/len(train\_loader):.4f}')

### 7. Evaluar el modelo

Después de entrenar, evaluamos el rendimiento del modelo en el conjunto de datos de prueba.


\# Evaluación

correct = 0

total = 0



with torch.no\_grad():

&#x20;   for images, labels in test\_loader:

&#x20;       outputs = model(images)

&#x20;       \_, predicted = torch.max(outputs.data, 1)

&#x20;       total += labels.size(0)

&#x20;       correct += (predicted == labels).sum().item()



print(f'Accuracy: {100 \* correct / total:.2f}%')

### 8. Ejecutar todo el proceso

Este código cargará el conjunto de datos CIFAR-10, entrenará una red convolucional simple durante 10 épocas y calculará la precisión del modelo en los datos de prueba. Con esto, ya tienes una CNN básica implementada en PyTorch.

### Posibles mejoras:

- **Aumentar la profundidad de la red**: Se pueden agregar más capas convolucionales.

- **Ajustar hiperparámetros**: Modificar el tamaño del lote, el número de épocas, o usar técnicas de regularización como el dropout.

- **Entrenar en GPU**: Si tienes acceso a una GPU, puedes mover el modelo y los datos a la GPU usando .to('cuda').

Este es solo el comienzo, y las redes convolucionales tienen muchas aplicaciones avanzadas que puedes explorar conforme te familiarices más con ellas.

Manuel Sosa

student•

🫶🏼🫶🏼

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
​
# Añadir capas totalmente conectadas en la parte superior
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))
​

750/750 ━━━━━━━━━━━━━━━━━━━━ 6s 4ms/step - accuracy: 0.8375 - loss: 0.5164 - val_accuracy: 0.9816 - val_loss: 0.0647
Epoch 2/5
750/750 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.9792 - loss: 0.0644 - val_accuracy: 0.9835 - val_loss: 0.0529
Epoch 3/5
750/750 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.9873 - loss: 0.0407 - val_accuracy: 0.9868 - val_loss: 0.0446
Epoch 4/5
750/750 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.9908 - loss: 0.0307 - val_accuracy: 0.9848 - val_loss: 0.0522
Epoch 5/5
750/750 ━━━━━━━━━━━━━━━━━━━━ 2s 3ms/step - accuracy: 0.9935 - loss: 0.0230 - val_accuracy: 0.9869 - val_loss: 0.0474
313/313 ━━━━━━━━━━━━━━━━━━━━ 1s 3ms/step - accuracy: 0.9867 - loss: 0.0439
Accuracy en el conjunto de prueba: 0.989300012588501
Model: "sequential_9"

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓
┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩
│ conv2d_13 (Conv2D)              │ (None, 26, 26, 32)     │           320 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_7 (MaxPooling2D)  │ (None, 13, 13, 32)     │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_14 (Conv2D)              │ (None, 11, 11, 64)     │        18,496 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ max_pooling2d_8 (MaxPooling2D)  │ (None, 5, 5, 64)       │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ conv2d_15 (Conv2D)              │ (None, 3, 3, 64)       │        36,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ flatten_3 (Flatten)             │ (None, 576)            │             0 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_6 (Dense)                 │ (None, 64)             │        36,928 │
├─────────────────────────────────┼────────────────────────┼───────────────┤
│ dense_7 (Dense)                 │ (None, 10)             │           650 │
└─────────────────────────────────┴────────────────────────┴───────────────┘
 Total params: 279,968 (1.07 MB)
 Trainable params: 93,322 (364.54 KB)
 Non-trainable params: 0 (0.00 B)
 Optimizer params: 186,646 (729.09 KB)

Este es el código que me funciono porque ya no hay soporte de 
keras en tensorflow:

import numpy as np
import tensorflow as tf
import keras
from keras import layers, Sequential
#from tensorflow import keras
import tf_keras as tk
from tf_keras.datasets import fashion_mnist
from tf_keras.layers import Conv2D, Dropout, MaxPooling2D, Flatten, Dense
#from tensorflow.keras.layers import Conv2D, Dropout, MaxPooling2D, Flatten, Dense
import matplotlib.pyplot as plt

(train_images, train_labels),(test_images, test_labels)=fashion_mnist.load_data()

train_images.shape

#Escalar los valores (255 porque va hasta 255 px)
train_images = train_images.astype('float32')/255
test_images = test_images.astype('float32')/255

train_images = train_images.reshape(train_images.shape[0],28,28,1)
test_images = test_images.reshape(test_images.shape[0],28,28,1)

train_labels[2]

train_labels = tk.utils.to_categorical(train_labels,10)
test_labels = tk.utils.to_categorical(test_labels,10)

##Modelo de datos

model = keras.Sequential()
model.add(keras.layers.Conv2D(filters=64, kernel_size=2,padding='same', activation='relu', input_shape=(28,28,1)))
model.add(keras.layers.MaxPooling2D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(keras.layers.Conv2D(filters=32, kernel_size=2,padding='same', activation='relu'))
model.add(keras.layers.MaxPooling2D(pool_size=2))
model.add(keras.layers.Dropout(0.3))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(256,activation='relu'))
model.add(keras.layers.Dropout(0.5))
model.add(keras.layers.Dense(10,activation='softmax'))
model.summary()

\# Definir transformaciones para normalizar y convertir a tensor

transform = transforms.Compose(\[

&#x20;   transforms.ToTensor(),

&#x20;   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))

])

\# Descargar el conjunto de datos CIFAR-10

train\_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)

test\_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform)

\# Cargar los datos en mini-lotes

train\_loader = DataLoader(train\_dataset, batch\_size=32, shuffle=True)

test\_loader = DataLoader(test\_dataset, batch\_size=32, shuffle=False)

class SimpleCNN(nn.Module):

&#x20;   def \_\_init\_\_(self):

&#x20;       super(SimpleCNN, self).\_\_init\_\_()

&#x20;       \# Primera capa convolucional: Conv2d(input\_channels, output\_channels, kernel\_size)

&#x20;       self.conv1 = nn.Conv2d(3, 32, kernel\_size=3, padding=1)

&#x20;       self.conv2 = nn.Conv2d(32, 64, kernel\_size=3, padding=1)

&#x20;      &#x20;

&#x20;       \# Max Pooling layer

&#x20;       self.pool = nn.MaxPool2d(kernel\_size=2, stride=2)

&#x20;      &#x20;

&#x20;       \# Fully connected layers

&#x20;       self.fc1 = nn.Linear(64 \* 8 \* 8, 512)  # CIFAR-10 images are 32x32, so after pooling, they're 8x8

&#x20;       self.fc2 = nn.Linear(512, 10)  # 10 output classes (for CIFAR-10)

&#x20;  &#x20;

&#x20;   def forward(self, x):

&#x20;       \# Aplicar la primera capa convolucional seguida de ReLU y max pooling

&#x20;       x = self.pool(F.relu(self.conv1(x)))

&#x20;      &#x20;

&#x20;       \# Segunda capa convolucional seguida de ReLU y max pooling

&#x20;       x = self.pool(F.relu(self.conv2(x)))

&#x20;      &#x20;

&#x20;       \# Aplanar los datos para conectarlos a las capas completamente conectadas

&#x20;       x = x.view(-1, 64 \* 8 \* 8)

&#x20;      &#x20;

&#x20;       \# Capa completamente conectada seguida de ReLU

&#x20;       x = F.relu(self.fc1(x))

&#x20;      &#x20;

&#x20;       \# Capa de salida (no necesitamos una activación aquí, ya que usaremos CrossEntropyLoss más adelante)

&#x20;       x = self.fc2(x)

&#x20;       return x

\# Entrenamiento

num\_epochs = 10  # Número de épocas de entrenamiento

for epoch in range(num\_epochs):

&#x20;   running\_loss = 0.0

&#x20;   for images, labels in train\_loader:

&#x20;       \# Forward pass

&#x20;       outputs = model(images)

&#x20;       loss = criterion(outputs, labels)

&#x20;      &#x20;

&#x20;       \# Backward pass y optimización

&#x20;       optimizer.zero\_grad()

&#x20;       loss.backward()

&#x20;       optimizer.step()

&#x20;      &#x20;

&#x20;       running\_loss += loss.item()

&#x20;  &#x20;

&#x20;   print(f'Epoch \[{epoch + 1}/{num\_epochs}], Loss: {running\_loss/len(train\_loader):.4f}')

\# Evaluación

correct = 0

total = 0

with torch.no\_grad():

&#x20;   for images, labels in test\_loader:

&#x20;       outputs = model(images)

&#x20;       \_, predicted = torch.max(outputs.data, 1)

&#x20;       total += labels.size(0)

&#x20;       correct += (predicted == labels).sum().item()

print(f'Accuracy: {100 \* correct / total:.2f}%')

Creando nuestra primera red convolucional

Redes convolucionales y su importancia

La importancia del computer vision

¿Qué herramientas usaremos para redes neuronales convolucionales?

¿Qué son las redes convolucionales?

Mi primera red neuronal convolucional

Creando nuestra primera red convolucional

Entrenando nuestra primera red convolucional

Manejo de imágenes

Consejos para el manejo de imágenes

Manejo de imágenes con Python

Fundamentos de redes neuronales convolucionales

Kernel en redes neuronales

El kernel en acción

Padding y Strides

Capa de pooling

Arquitectura de redes convolucionales

Resolviendo un problema de clasificación

Clasificación con redes neuronales convolucionales

Creación de red convolucional para clasificación

Entrenamiento de un modelo de clasificación con redes convolucionales

Optimización de red neuronal convolucional

Data augmentation

Aplicando data augmentation

Callbacks: early stopping y checkpoints

Batch normalization

Optimización de modelo de clasificación

Entrenamiento de nuestro modelo de clasificación optimizado

Resolviendo una competencia de Kaggle

Clasificando entre perros y gatos

Entrenamiento del modelo de clasificación de perros y gatos

Resumen y siguientes pasos

Siguientes pasos con redes neuronales convolucionales

Comparte tu proyecto de clasificación con redes convolucionales y certifícate