Saltar navegación

Reto 12: Quen ten o mellor cerebro?

O mellor cerebro artificial

Duración:
120 min
Agrupamento:
2
Cerebro
Copilot. Cerebro (CC BY-SA)

Estrutura do reto

  • Fase 1: Configuración → Cada equipo debe axustar os parámetros da súa rede: capas ocultas, número de neuronas, activacións, optimizador, taxa de aprendizaxe e épocas.
  • Fase 2: Adestramento → A rede neuronal entrena con MNIST, e visualiza as curvas de aprendizaxe para comprobar se mellora.
  • Fase 3: Predición → Cada equipo testea a súa rede coas imaxes separadas para proba, e mide cantas predicións son correctas.
  • Fase 4: Xestión e Axustes → Debedes crear a función de xestión da rede e probala. Se a rede falla moito, reconfigúrase ou readéstrase modificando os parámetros.
  • Fase 5: Comparación final → Comparar as porcentaxes de acerto entre os equipos e descubrir a mellor rede da clase!

Lembra:A IA está para axudarche, pregúntalle!

Librerías e clase de modelo preciso para este reto

No caderno de colab donde desenroles este reto, debes poñer arriba de todo para que sexa accesible para todas as celdas:

Fase 1: Configurar a rede neuronal

Cada equipo elixirá os parámetros da súa rede.

Esta é a función que configura a rede neuronal.

Fase 2: Crear e adestrar a rede neuronal

Cada equipo terá a súa rede personalizada, escollerá os parámetros de adestramento e verá como mellora ao longo do tempo.

Esta é a función que adestra a rede neuronal.

Fase 3: Probar o modelo coas imaxes separadas ao principio

Cada equipo subirá imaxes (zip - 11406 B) e medirá cantas predicións son correctas.

Esta é a función que proba a rede neuronal.

Fase 4: Función de xestión. Axustes e melloras

Tarefa: Xestión dunha Rede Neuronal

Obxectivo: Implementar a función programa_principal() para xestionar unha rede neuronal que realiza tres tarefas principais: configurar a rede, adestrala e probala.

Funcións auxiliares xa implementadas:

  • configurar_rede() → Configura os parámetros da rede.
  • adestrar_modelo() → Adestra a rede neuronal cos datos.
  • proba_modelo() → Proba a rede neuronal con imaxes.

✍️ Tarefa:

Implementa a función programa_principal() seguindo estes requisitos:

  • Debe executar configurar_rede(), adestrar_modelo() e proba_modelo() nunha orde lóxica.
  • Debe incluír un menú interactivo que permita ao usuario modificar a configuración, re-adestrar ou probar novas imaxes.
  • Debe validar as opcións introducidas polo usuario.

Exemplo de saída esperada:

Executando o programa principal...

Configuración da rede neuronal


Número de capas ocultas (Exemplo: 1, 2, 3,etc): 3

Número de neuronas por capa oculta (Exemplo: 128, 256, 512): 128

Escolle a función de activación
1 - ReLU (Axuda en redes profundas)
2 - Sigmoid (Útil para clasificación simple)
3 - Tanh (Axuda en valores negativos e positivos)
Elixe 1-ReLU, 2-Sigmoid, 3-Tanh: 3

Escolle o optimizador
1 - SGD (Simple pero lento)
2 - Adam (Máis rápido, mellora en problemas complexos)
3 - RMSprop (Ideal para datos ruidosos)
Elixe 1-SGD, 2-Adam, 3-RMSprop: 3

Configuración da rede neuronal:
+-------------------+---------------------------------------+
| Parámetro       |          Valor |
+===================+=============+
| Capas ocultas |                 3 |
+-------------------+---------------------------------------+
| Neuronas por capa |   128 |
+-------------------+---------------------------------------+
| Activación |               Tanh() |
+-------------------+---------------------------------------+
| Optimizador | <class 'torch.optim.rmsprop.RMSprop'> |
+-------------------+---------------------------------------+


A REDE NEURONAL ESTÁ CONFIGURADA E LISTA PARA ADESTRARSE!

Escolle os parámetros da aprendizaxe
Taxa de aprendizaxe (Exemplo: 0.01, 0.001): 0.01
Número de épocas de adestramento (Exemplo: 5, 10, 20): 5
Tamaño dos lotes (Exemplo: 16, 32, 64): 64

Iniciando o adestramento do modelo...
Época 1: Perda = 0.5029, Precisión = 0.8623
Época 2: Perda = 0.1925, Precisión = 0.9350
Época 3: Perda = 0.0898, Precisión = 0.9481
Época 4: Perda = 0.1407, Precisión = 0.9538
Época 5: Perda = 0.0248, Precisión = 0.9571

O adestramento completouse con éxito!
O MODELO ESTÁ LISTO PARA REALIZAR PREDICIÓNS

Modo de predición activado! Sube unha imaxe e o modelo fará unha predición.
Cando queiras rematar verás a taxa de acerto.


mnist_digit_7_9.png(image/png) - 279 bytes, last modified: 5/6/2025 - 100% done
Saving mnist_digit_7_9.png to mnist_digit_7_9 (1).png

Predicións do modelo:

7 (100.00%)
9 (0.00%)
1 (0.00%)

Acertou o modelo? (s/n): s

Queres subir outra imaxe? (s/n): s

mnist_digit_5_20.png(image/png) - 285 bytes, last modified: 5/6/2025 - 100% done
Saving mnist_digit_5_20.png to mnist_digit_5_20 (1).png

Predicións do modelo:

5 (97.18%)
3 (1.09%)
8 (0.94%)

Acertou o modelo? (s/n): s

Queres subir outra imaxe? (s/n): s

mnist_digit_3_18.png(image/png) - 355 bytes, last modified: 5/6/2025 - 100% done
Saving mnist_digit_3_18.png to mnist_digit_3_18 (1).png

Predicións do modelo:

3 (92.73%)
9 (6.65%)
5 (0.25%)

Acertou o modelo? (s/n): s

Queres subir outra imaxe? (s/n): n

TAXA DE ACERTO DO MODELO: 100.00%

Modo de predición finalizado!


QUE QUERES FACER AGORA?
1 - Modificar a configuración e re-adestrar
2 - Modificar os parámetros de adestramento e re-adestrar
3 - Volver a probar o modelo con novas imaxes
4 - Saír
Elixe unha opción (1/2/3/4): 4

Programa finalizado! Grazas por usar a rede neuronal.

Entrega:

Escribe a función programa_principal() seguindo os requisitos anteriores e integrala coas funcións auxiliares. Asegúrate de que a interacción coa usuaria sexa clara e eficiente.

Código Python: Librerías para reto 12

# Bibliotecas principais
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import torch.utils.data
import torch.nn.functional as F
import numpy as np

# Manipulación de imaxes
from PIL import Image, ImageOps
from google.colab import files  # Para subir imaxes en Colab

# Visualización
import matplotlib.pyplot as plt
from tabulate import tabulate  # Para presentar os parámetros da rede en táboas

Código Python: Estrutura de rede para reto 12

class CustomNN(nn.Module):
    def __init__(self, num_capas, tam_oculta, activacion):
        super(CustomNN, self).__init__()

        # Mapear activación correctamente
        activaciones_map = {"ReLU": nn.ReLU(), "Sigmoid": nn.Sigmoid(), "Tanh": nn.Tanh()}
        self.activacion = activaciones_map.get(str(activacion), nn.ReLU())  # Converte `activacion` nun string se fose necesario

        # Capas da rede
        self.capas = nn.ModuleList()
        self.capas.append(nn.Linear(28*28, tam_oculta))

        for _ in range(num_capas - 1):
            self.capas.append(nn.Linear(tam_oculta, tam_oculta))

        self.saida = nn.Linear(tam_oculta, 10)  # Última capa para clasificación en 10 clases

        # Se queremos engadir capa dropout
        #self.dropout = nn.Dropout(p=0.5)  # P = 0.2 significa que o 20% das neuronas se desactivan aleatoriamente. Evita sobreaxuste.

    def forward(self, x):
        x = x.view(x.size(0), -1)  # Remodelar entrada
        for capa in self.capas:
            x = self.activacion(capa(x))
          # x = self.dropout(x)  # Aplicar dropout despois de cada activación se apreciamos sobreaxuste
        x = self.saida(x)  # Última capa sen activación
        return x

Código Python: Función que configura a rede neuronal cos parámetros escollidos

# FUNCIÓN PARA CONFIGURAR A REDE


def configurar_rede():
    global num_capas, tam_oculta, activacion, optimizador_func

    print("\nConfiguración da rede neuronal\n")
    num_capas = int(input("\nNúmero de capas ocultas (Exemplo: 1, 2, 3,etc): "))
    tam_oculta = int(input("\nNúmero de neuronas por capa oculta (Exemplo: 128, 256, 512): "))

    print("\nEscolle a función de activación")
    print("1 - ReLU (Axuda en redes profundas)")
    print("2 - Sigmoid (Útil para clasificación simple)")
    print("3 - Tanh (Axuda en valores negativos e positivos)")
    activacion_map = {1: nn.ReLU(), 2: nn.Sigmoid(), 3: nn.Tanh()}
    activacion_opc = int(input("Elixe 1-ReLU, 2-Sigmoid, 3-Tanh: "))
    activacion = activacion_map.get(activacion_opc, nn.ReLU())

    print("\nEscolle o optimizador")
    print("1 - SGD (Simple pero lento)")
    print("2 - Adam (Máis rápido, mellora en problemas complexos)")
    print("3 - RMSprop (Ideal para datos ruidosos)")
    optimizador_map = {1: optim.SGD, 2: optim.Adam, 3: optim.RMSprop}
    optimizador_opc = int(input("Elixe 1-SGD, 2-Adam, 3-RMSprop: "))
    optimizador_func = optimizador_map.get(optimizador_opc, optim.Adam)



    # Crear a táboa cos valores seleccionados
    datos_rede = [
        ["Capas ocultas", num_capas],
        ["Neuronas por capa", tam_oculta],
        ["Activación", activacion],
        ["Optimizador", optimizador_func]

    ]

    print("\nConfiguración da rede neuronal:")
    print(tabulate(datos_rede, headers=["Parámetro", "Valor"], tablefmt="grid"))

    # Mensaxe final indicando que está lista
    print("\n\nA REDE NEURONAL ESTÁ CONFIGURADA E LISTA PARA ADESTRARSE!")

Código Python: Función que adestra a rede neuronal cos parámetros escollidos e grafica o proceso

# FUNCIÓN PARA ADESTRAR A REDE

def adestrar_modelo():
    global model, losses, accuracies, taxa_aprendizaxe, num_epocas, batch_size

    print("\nEscolle os parámetros da aprendizaxe")

    taxa_aprendizaxe = float(input("Taxa de aprendizaxe (Exemplo: 0.01, 0.001): "))
    num_epocas = int(input("Número de épocas de adestramento (Exemplo: 5, 10, 20): "))
    batch_size = int(input("Tamaño dos lotes (Exemplo: 16, 32, 64): "))



    print("\nIniciando o adestramento do modelo...")

    # Crear o modelo cos parámetros configurados
    model = CustomNN(num_capas, tam_oculta, activacion)
    optimizer = optimizador_func(model.parameters(), lr=taxa_aprendizaxe)
    criterion = nn.CrossEntropyLoss()

    # Cargar o conxunto de datos MNIST
    transform = transforms.Compose([transforms.ToTensor()])
    dataset = torchvision.datasets.MNIST(root="./data", train=True, transform=transform, download=True)
    loader = torch.utils.data.DataLoader(dataset, batch_size=batch_size, shuffle=True)

    losses = []
    accuracies = []

    # Adestrar a rede neuronal
    for epoch in range(num_epocas):
        correct = 0
        total = 0
        for images, labels in loader:
            optimizer.zero_grad()
            outputs = model(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
            losses.append(loss.item())

            # Calcular precisión
            predictions = torch.argmax(outputs, dim=1)
            correct += (predictions == labels).sum().item()
            total += labels.size(0)

        accuracy = correct / total
        accuracies.append(accuracy)
        print(f"Época {epoch+1}: Perda = {loss.item():.4f}, Precisión = {accuracy:.4f}")

    # Mostrar gráficas da aprendizaxe
    plt.figure(figsize=(10, 4))
    plt.subplot(1, 2, 1)
    plt.plot(losses, label="Perda", color="red")
    plt.title("Curva de perda")
    plt.xlabel("Iteracións")
    plt.ylabel("Perda")
    plt.legend()

    plt.subplot(1, 2, 2)
    plt.plot(accuracies, label="Precisión", color="blue")
    plt.title("Curva de precisión")
    plt.xlabel("Épocas")
    plt.ylabel("Precisión")
    plt.legend()

    plt.show()

    # Mensaxe final
    print("\nO adestramento completouse con éxito! \nO MODELO ESTÁ LISTO PARA REALIZAR PREDICIÓNS")

Código Python: Función que proba a rede neuronal coas imaxes subidas

#FUNCIÓN PARA PROBAR A REDE

def proba_modelo():
    global total_predicions , total_acertos
    total_predicions = 0  # Inicializa a variable
    total_acertos = 0


    print("\nModo de predición activado! Sube unha imaxe e o modelo fará unha predición.")
    print("Cando queiras rematar verás a taxa de acerto.\n")

    while True:
        # Subir imaxe
        uploaded = files.upload()
        filename = list(uploaded.keys())[0]

        #Preparamos o formato da imaxe e a convertimos nun tensor que a rede "comprenda"
        image = Image.open(filename).convert("L")
        image_tensor = torch.tensor(np.array(image) / 255.0).unsqueeze(0).unsqueeze(0).float()

        # Predición do modelo
        outputs = model(image_tensor)
        probabilities = torch.nn.functional.softmax(outputs, dim=1)
        top3 = torch.topk(probabilities, 3)

        total_predicions += 1  # Rexistrar cantas imaxes se analizaron

        print("\nPredicións do modelo:\n")
        for i in range(3):
            print(f" {top3.indices[0][i].item()} ({top3.values[0][i].item()*100:.2f}%)")

        resposta = input("\n Acertou o modelo? (s/n): ").strip().lower()
        if resposta == "s":
            total_acertos += 1  # Rexistrar os acertos

        continuar = input("\nQueres subir outra imaxe? (s/n): ").strip().lower()
        if continuar == "n":
            break

    # Mostra a taxa de acerto ao finalizar
    if total_predicions > 0:
        print(f"\nTAXA DE ACERTO DO MODELO: {total_acertos/total_predicions*100:.2f}%")
    else:
        print("\nNon se subiron imaxes para predicir.")

    print("\n Modo de predición finalizado! ")

Rúbrica de avaliación

Rúbrica Reto 12: O mellor cerebro artificial
Criterio Excelente (9-10) Bo (7-8) Aceptable (5-6) Mellorable (3-4) Moi mellorable (0-2)
Importación das librerías e estrutura do modelo Importa correctamente todas as librerías necesarias e configura a estrutura da rede. Librerías importadas correctamente pero con pequenas melloras posibles. Librerías utilizadas pero con problemas na implementación do modelo. Erro na configuración do modelo. Non define nin importa as librerías necesarias.
Configuración da rede neuronal Define correctamente os parámetros da rede, número de capas, neuronas, activación e optimización. Configuración realizada pero con melloras posibles na parametrización. Rede configurada pero con problemas ocasionais na xestión dos parámetros. Erro na configuración da rede neuronal. Non define a configuración da rede.
Adestramento da rede Adestra correctamente o modelo e mostra curvas de perda e precisión. Adestramento realizado pero con pequenas dificultades na optimización. Modelo adestrado pero con problemas ocasionais na validación. Erro na división dos datos ou no proceso de adestramento. Non realiza o adestramento do modelo.
Visualización do proceso de aprendizaxe Gráficas ben elaboradas mostrando a evolución da perda e da precisión. Visualización ben feita pero con melloras posibles. Gráfica realizada pero con dificultade na interpretación dos resultados. Erro na xestión ou comprensión das gráficas. Non realiza ningunha visualización do adestramento.
Proba da rede neuronal con imaxes Permite ao usuario subir imaxes, realiza predicións e calcula taxa de acerto. Proba funcional pero con melloras posibles na interacción. Proba realizada pero con problemas ocasionais na resposta. Erro na proba do modelo. Non implementa funcionalidade de proba.
Interacción co usuario Solicita entrada de datos de maneira clara e permite interacción iterativa. Interacción ben feita pero con pequenas melloras posibles. Interacción realizada pero con dificultades na fluidez do proceso. Erro na comunicación dos resultados ao usuario. Non implementa interacción co usuario.
Xestión e axuste do modelo Implementa un sistema de menú que permite modificar parámetros e reconfigurar a rede. Xestión ben feita pero con melloras posibles na optimización do menú. Xestión realizada pero con problemas ocasionais na navegación. Erro na modificación ou reutilización do modelo. Non implementa xestión do modelo.
Explicación das métricas e gráficas Describe correctamente o significado das métricas utilizadas. Explicación das métricas ben feita pero con melloras posibles. Interpretación das métricas con dificultades na súa comprensión. Erro na explicación das métricas. Non explica as métricas utilizadas.
Actitude ante os problemas Busca solucións e optimiza os procesos de configuración e aprendizaxe. Resolve os problemas con esforzo e consulta documentación. Resolve con dificultades pero sen explorar melloras. Resígnase ante os erros sen buscar alternativas. Non intenta resolver os problemas ou abandona o traballo.
Traballo colaborativo Comunicación eficaz e traballo equilibrado en parella. Traballo en equipo con pequenas dificultades. Interacción mínima, traballo case independente. Pouca colaboración, realízase gran parte do traballo de forma individual. Non colabora coa parella nin contribúe ao traballo conxunto.