Solución

• Este é un programa en Python que podes executar en Google Colaboratory para descargar e manipular o dataset MINST.
• O programa inclue explicacións detalladas nos comentarios para que comprendas cada paso.
• Executandoo en Colab, podes probar a descargar o dataset, ver exemplos dos datos que contén e separar 25 imaxes para probas posteriores.
• Non te preocupes por comprender o programa totalmente, só de entender o que fai.
• MINST é o "Ola mundo" dos dataset. Contén imaxes de díxitos con características moi concretas. Se usamos outras para probas, adoitan dar problemas ou non predicirse correctamente, de aí que separemos no inicio, 25 imaxes que usa para validación e non "aprende" no adestramento.

Resultado esperado

Explicación dos métodos de Pytorch:

Este código emprega PyTorch e Torchvision para descargar, visualizar e gardar imaxes do dataset MNIST, un conxunto de datos de números escritos a man. 

torchvision.datasets.MNIST(root="./data", train=True, transform=transforms.ToTensor(), download=True)

Función: Descarga e carga o dataset MNIST.

Parámetros clave:

root="./data" → Indica o directorio onde se gardarán os datos.

train=True → Especifica que queremos as imaxes de adestramento.

transform=transforms.ToTensor() → Convirte as imaxes en tensores.

download=True → Se os datos non están gardados previamente, descárgaos automaticamente.

image = image.squeeze(0) * 255

Función: Elimina a dimensión innecesaria do tensor e escala os valores de 0-1 a 0-255. 

Explicación:

squeeze(0) → Elimina a dimensión extra do tensor porque MNIST ten só unha canle (escala de grises).

* 255 → Convértese os valores de píxeles de 0-1 a 0-255, para que poidan ser gardados como imaxes reais.

(Proba: Comenta a liña * 255 e observa que ao gardar as imaxes, aparecen moito máis escuras porque os valores quedan entre 0-1.)

transform = transforms.ToTensor()

Función: Convirte as imaxes nun tensor de PyTorch, onde cada píxel terá valores entre 0.0 e 1.0.

Uso común: Axuda a preparar imaxes para redes neuronais.

(Proba: Substitúe transforms.ToTensor() por transforms.Normalize((0.5,), (0.5,)) e observa que os valores do tensor agora estarán centrados arredor de 0.)

image = Image.fromarray(image.numpy().astype("uint8"))

Función: Convirte un tensor PyTorch nunha imaxe estándar en formato PIL.

Explicación:

.numpy() → Convirte o tensor nun array NumPy.

.astype("uint8") → Convértese os valores do tensor en enteros (0-255) para que poida ser gardado como imaxe.

( Proba: Garda a imaxe en formato .jpg en vez de .png cambiando image.save(f"mnist_digit_{label}_{i}.png") por image.save(f"mnist_digit_{label}_{i}.jpg").)  

Posibles actividades adicionais:

Mostrar só os díxitos impares do dataset. Filtra e visualiza só os números 1, 3, 5, 7, 9.

for i in range(25):

image, label = mnist_val[i]

if label % 2 != 0: # Só díxitos impares

plt.imshow(image.squeeze(0), cmap="gray")
plt.title(f"Dígito impar: {label}")
plt.axis("off")
plt.show()

Modificar a escala das imaxes gardadas. Cambia o tamaño das imaxes antes de gardalas.

image = image.resize((50, 50)) # Redimensiona a imaxe a 50x50 píxeles
image.save(f"mnist_digit_{label}_{i}_resized.png")

Usar unha transformación diferente. Aplica un filtro de inversión ás imaxes antes de gardalas.

transform = transforms.Compose([
transforms.ToTensor(),
transforms.Lambda(lambda x: 1 - x) # Invertemos os valores, os píxeles negros pasan a ser brancos
])

Solución

• Este é un programa en Python que podes executar en Google Colaboratory  para crear e adestrar unha rede neuronal simple con Pytorch.
• O programa inclue explicacións detalladas nos comentarios para que comprendas cada paso.
• Executandoo en Colab, podes probar a e visualizar a aprendizaxe da rede.
• Non te preocupes por comprender o programa totalmente, só de entender o que fai.
• Investiga cada parámetro que non coñezas.

Resultado esperado

Explicación dos métodos de Pytorch:

Métodos de PyTorch utilizados no código

 torch.nn.Module → Definir modelos de redes neuronais

class SimpleNN(nn.Module):

def __init__(self):

super(SimpleNN, self).__init__()
self.fc1 = nn.Linear(28*28, 128) # Capa oculta con 128 neuronas
self.fc2 = nn.Linear(128, 10) # Capa de saída con 10 clases

def forward(self, x):

x = x.view(-1, 28*28) # Aplanar imaxes de 28x28 píxeles a un vector de 784 elementos
x = torch.relu(self.fc1(x)) # Activación ReLU na primeira capa
x = self.fc2(x) # Obtención da saída sen activación final (CrossEntropyLoss xa a aplica)
return x

Define a arquitectura dun modelo simple con duas capas totalmente conectadas. Usa torch.relu() para introducir non linealidade na rede neuronal. O método forward() define como os datos pasan polo modelo.

 torch.nn.Linear → Capas totalmente conectadas

self.fc1 = nn.Linear(28*28, 128)
self.fc2 = nn.Linear(128, 10)

nn.Linear(in_features, out_features) crea unha capa de neuronas, conectando todas as entradas con todas as saídas.Transforma os datos mediante multiplicacións de matrices e sumas de sesgos.

 torch.nn.CrossEntropyLoss → Función de perda

criterion = nn.CrossEntropyLoss()

Calcular a diferencia entre as predicións do modelo e as etiquetas reais usando probabilidades softmax. É ideal para clasificación multiclase (como recoñecer números 0-9 en MNIST).
 

 torch.optim.SGD → Optimización do modelo

optimizer = optim.SGD(model.parameters(), lr=0.01)

Actualiza os pesos do modelo despois de cada iteración para reducir a perda. Usa o método Gradiente Estocástico (SGD) para mellorar a precisión.

 torch.argmax → Predición das clases

predictions = torch.argmax(outputs, dim=1)

Obten o índice da clase máis probable predita polo modelo. Se outputs é tensor([[0.1, 3.2, 1.5], [2.1, 0.3, 0.8]]), torch.argmax(outputs, dim=1) devolve [1, 0], indicando as clases predicidas.
 

 torch.utils.data.DataLoader → Cargar datos en lotes

train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)

Carga os datos en lotes pequenos para evitar problemas de memoria. batch_size=64 divide os datos en lotes de 64 imaxes por iteración. shuffle=True mestura as imaxes para evitar que o modelo aprenda patróns estraños vendo sempre o mesmo díxito.

 loss.backward() → Retropropagación

loss.backward()

Calcula os gradientes dos parámetros para actualizar os pesos do modelo. Permite mellorar as conexións entre as neuronas. 

Posibles actividades adicionais:

Engade unha nova capa oculta con nn.Linear(128, 64) e observa o impacto na precisión.

Cambia nn.Linear(28*28, 128) por nn.Linear(28*28, 256) e observa se mellora o modelo.

Substitúe nn.CrossEntropyLoss() por nn.MSELoss() e observa como afecta o adestramento (MSE úsase máis en regresión que en clasificación).

Cambia optim.SGD(model.parameters(), lr=0.01) por optim.Adam(model.parameters(), lr=0.001) e compara a rapidez do adestramento.

Cambia torch.argmax(outputs, dim=1) por torch.softmax(outputs, dim=1) e observa os valores predicidos (dará probabilidades en vez de clases).

Cambia batch_size=64 por batch_size=256 e observa como afecta a rapidez do adestramento e ó número de iteracións.

Engade print(model.fc1.weight.grad) para ver como os gradientes cambian en cada iteración.

Aumenta o número de capas da rede e compara os resultados. 

Visualiza algunhas imaxes mal clasificadas para entender os erros do modelo.

Usa outra función de activación como torch.sigmoid() en vez de torch.relu().

Solución

• Este é un programa en Python que podes executar en Google Colaboratory  para probar o modelo adestrado
• O programa inclue explicacións detalladas nos comentarios para que comprendas cada paso.
• Executandoo en Colab, podes probar a subir imaxes do conxunto de 25 que separaches e predicir co modelo que díxito é.
• Non te preocupes por comprender o programa totalmente, só de entender o que fai.
• Razona coas porcentaxes que saen:acerta ou non? Ten algo a imaxe que poda inducir a erro.

Resultado esperado

Explicación dos métodos de Pytorch:

Métodos de PyTorch utilizados

 torchvision.transforms → Transformacións de imaxes

transform = transforms.Compose([
transforms.Resize((28, 28)), # Redimensiona a imaxe a 28x28 píxeles (tamaño estándar en MNIST)
transforms.ToTensor(), # Convértese a imaxe nun tensor con valores entre 0 e 1
transforms.Normalize((0.5,), (0.5,)) # Normaliza os valores para mellorar a predición
])
image_tensor = transform(image).unsqueeze(0) # Engade unha dimensión de lote

transforms.Resize((28, 28)) → Redimensiona a imaxe para que se adapte ao modelo.

transforms.ToTensor() → Convértese cada píxel en valores entre 0.0 e 1.0.

transforms.Normalize((0.5,), (0.5,)) → Centra os valores arredor de 0 (máis eficiente para a rede neuronal).

.unsqueeze(0) → Engade unha dimensión de lote, facendo que a imaxe sexa válida para o modelo(quitarámola antes para gardala como png).

model.eval() → Poñer o modelo en modo de avaliación

model.eval()

Pon o modelo en modo de avaliación, desactivando capas como Dropout e BatchNorm.Evita que o modelo modifique parámetros durante a predición.

torch.no_grad() → Desactivar o cálculo de gradientes

with torch.no_grad():
output = model(image_tensor)

Evita o cálculo innecesario de gradientes, reducindo o uso de memoria e aumentando a eficiencia.Indicado para predicións, xa que non se realiza adestramento.
 

torch.softmax() → Obtención de probabilidades

probabilities = torch.softmax(output, dim=1)

Converte os valores da saída do modelo en probabilidades (entre 0 e 1).Facilita a interpretación dos resultados.
 

 torch.topk() → Seleccionar as opcións máis probables

top3 = torch.topk(probabilities, 3)

Obten os 3 números máis probables predicidos polo modelo. Devolve tanto os valores coma as probabilidades asociadas.

Posibles actividades adicionais:

Cambia a normalización Normalize((0.5,), (0.5,)) por Normalize((0.2,), (0.2,)) e observa como cambia a saída.

Executa print(model.training) antes e despois de model.eval() para ver o cambio no estado do modelo.

Retira torch.no_grad() e observa o impacto no uso de memoria.

Mostra os valores antes e despois de aplicar softmax() para ver a diferenza.

Modifica topk(3) por topk(5) e observa a saída.