Creando nuestra primera red convolucional

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

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

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

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)

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

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

```python 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() ```

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`: ```bash pip install torch torchvision ``` \### 2. Importar las bibliotecas necesarias ```python 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. ```python \# Definir transformaciones para normalizar y convertir a tensor transform = transforms.Compose(\[ transforms.ToTensor(), 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. ```python class SimpleCNN(nn.Module): def \_\_init\_\_(self): super(SimpleCNN, self).\_\_init\_\_() \# Primera capa convolucional: Conv2d(input\_channels, output\_channels, kernel\_size) self.conv1 = nn.Conv2d(3, 32, kernel\_size=3, padding=1) self.conv2 = nn.Conv2d(32, 64, kernel\_size=3, padding=1) \# Max Pooling layer self.pool = nn.MaxPool2d(kernel\_size=2, stride=2) \# Fully connected layers self.fc1 = nn.Linear(64 \* 8 \* 8, 512) # CIFAR-10 images are 32x32, so after pooling, they're 8x8 self.fc2 = nn.Linear(512, 10) # 10 output classes (for CIFAR-10) def forward(self, x): \# Aplicar la primera capa convolucional seguida de ReLU y max pooling x = self.pool(F.relu(self.conv1(x))) \# Segunda capa convolucional seguida de ReLU y max pooling x = self.pool(F.relu(self.conv2(x))) \# Aplanar los datos para conectarlos a las capas completamente conectadas x = x.view(-1, 64 \* 8 \* 8) \# Capa completamente conectada seguida de ReLU x = F.relu(self.fc1(x)) \# Capa de salida (no necesitamos una activación aquí, ya que usaremos CrossEntropyLoss más adelante) x = self.fc2(x) 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. ```python 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. ```python \# Entrenamiento num\_epochs = 10 # Número de épocas de entrenamiento for epoch in range(num\_epochs): running\_loss = 0.0 for images, labels in train\_loader: \# Forward pass outputs = model(images) loss = criterion(outputs, labels) \# Backward pass y optimización optimizer.zero\_grad() loss.backward() optimizer.step() running\_loss += loss.item() 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. ```python \# Evaluación correct = 0 total = 0 with torch.no\_grad(): for images, labels in test\_loader: outputs = model(images) \_, predicted = torch.max(outputs.data, 1) total += labels.size(0) 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.

🫶🏼🫶🏼