Bienvenido, me llamo Luis y aquí les traigo este nuevo tutorial.
Índice
Aprenderá a cargar imágenes descargadas a PyTorch en cuestión de minutos
Hoy cubriremos lo siguiente:
- Cómo almacenar imágenes correctamente, para que pueda etiquetar fácilmente sus datos.
- Cómo acceder a los datos usando PyTorch y hacer algunos preprocesos en el camino.
- Al final, usaremos una CNN muy simple para clasificar nuestras imágenes.
Lo primero es lo primero, ¿Cómo almacenar los datos?
Usaré esta conjunto de datos, que contiene las imágenes de perros y gatos.
La forma más fácil de almacenar sus imágenes es crear una carpeta para cada clase, nombrando la carpeta con el nombre de la clase.
Déjame mostrarte un ejemplo:
Simplemente nombrando sus carpetas correctamente, le permitirá a PyTorch saber a qué clase hacer valer una imagen.
Ahora, vayamos al código
import matplotlib.pyplot as plt from torchvision import datasets, transforms from torch.utils.data import DataLoader import torch.nn as nn import torch.nn.functional as F import torch.optim as optim import torchdef get_data(): data_dir = '/your_path/Data/' train_set = datasets.ImageFolder(data_dir + '/training_set') test_set = datasets.ImageFolder(data_dir + '/test_set') return train_set, test_set
La función anterior obtiene los datos del directorio. Simplemente tiene que especificar la ruta a su Juego de trenes y Equipo de prueba carpetas. PyTorch asignará automáticamente las etiquetas a las imágenes, utilizando los nombres de las carpetas en el directorio especificado.
Sin embargo, es posible que desee realizar un preprocesamiento antes de usar las imágenes, así que hagámoslo y, además, creemos un DataLoader inmediatamente. Para hacerlo, agreguemos algunas líneas nuevas al código anterior.
def get_data(): data_dir = '/your_path/Data/' transform = transforms.Compose([ #transforms.RandomRotation(20), transforms.RandomResizedCrop(128), #transforms.RandomHorizontalFlip(), transforms.ToTensor()]) train_set = datasets.ImageFolder(data_dir + '/training_set', transform=transform) test_set = datasets.ImageFolder(data_dir + '/test_set', transform=transform) train = DataLoader(train_set, batch_size=32, shuffle=True) test = DataLoader(test_set, batch_size=32, shuffle=True) return train, test
Como las transformaciones, es posible que desee recortar, voltear, cambiar el tamaño, rotar, etc. las imágenes. Para hacerlo, puede especificar todas las cosas que necesita en un solo lugar, utilizando transforma. Entonces puedes crear el DataLoader con tus imágenes cargadas.
Ahí es donde entra en juego una CNN
Ahora, cuando tenga los datos listos, es posible que desee echarles un vistazo rápido. Para ello, puede utilizar esta sencilla función, que mostrará las primeras 5 imágenes.
def train_imshow(): classes = ('cat', 'dog') # Defining the classes we have dataiter = iter(train) images, labels = dataiter.next() fig, axes = plt.subplots(figsize=(10, 4), ncols=5) for i in range(5): ax = axes[i] ax.imshow(images[i].permute(1, 2, 0)) ax.title.set_text(' '.join('%5s' % classes[labels[i]])) plt.show()
Definamos nuestra red neuronal convolucional:
class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1 = nn.Conv2d(3, 6, 5) self.pool = nn.MaxPool2d(8, 8) self.conv2 = nn.Conv2d(6, 16, 5) self.fc1 = nn.Linear(16, 100) self.fc2 = nn.Linear(100, 50) self.fc3 = nn.Linear(50, 2) def forward(self, x): x = self.pool(F.relu(self.conv1(x))) x = self.pool(F.relu(self.conv2(x))) x = x.view(-1, 16) x = F.relu(self.fc1(x)) x = F.relu(self.fc2(x)) x = self.fc3(x) return x
Usé la red definida aquí y lo modifiqué un poco para que ahora pueda funcionar con mis imágenes.
Ahora podemos especificar el criterio, el optimizador, la tasa de aprendizaje y entrenar la red.
criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=0.01, momentum=0.9)if torch.cuda.is_available(): # Checking if we can use GPU model = net.cuda() criterion = criterion.cuda() def train_net(n_epoch): # Training our network losses = [] for epoch in range(n_epoch): # loop over the dataset multiple times running_loss = 0.0 for i, data in enumerate(train, 0): # get the inputs; data is a list of [inputs, labels] inputs, labels = data # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs = net(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() # print statistics losses.append(loss) running_loss += loss.item() if i % 100 == 99: # print every 2000 mini-batches print('[%d, %5d] loss: %.10f' % (epoch + 1, i + 1, running_loss / 2000)) running_loss = 0.0 plt.plot(losses, label='Training loss') plt.show() print('Finished Training')
Puede guardar y cargar su red entrenada.
PATH = './cat_dog_net.pth' torch.save(net.state_dict(), PATH) # Loading the trained network net.load_state_dict(torch.load(PATH))
Introduzcamos nuestras imágenes de prueba en la red.
correct = 0 total = 0 with torch.no_grad(): for data in test: images, labels = data outputs = net(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the network on the %d test images: %d %%' % (len(test), 100 * correct / total))
El error del equipo de prueba es 66%, lo cual no está mal, aunque obtener la mayor precisión posible no es el objetivo de este artículo.
Aquí puedes encontrar el código completo.
¡Bien hecho! ¡Ahora estás listo para practicar en aprendizaje profundo usando tus imágenes!
Gracias por leer.
Añadir comentario