IMG_2983.jpeg

# Guía de inicio rápido de PyTorch ## ¿Qué es PyTorch? PyTorch es un marco de aprendizaje automático de código abierto basado en la biblioteca Torch, utilizado para aplicaciones como el procesamiento del lenguaje natural y la visión artificial, desarrollado principalmente por Meta AI. ## Empezand...

# Guía de inicio rápido de PyTorch ## ¿Qué es PyTorch? PyTorch es un marco de aprendizaje automático de código abierto basado en la biblioteca Torch, utilizado para aplicaciones como el procesamiento del lenguaje natural y la visión artificial, desarrollado principalmente por Meta AI. ## Empezando ### Instalación Para instalar PyTorch, le recomendamos que utilice el administrador de paquetes conda. También puede instalar PyTorch utilizando pip. #### Instalación con Conda ``` conda install pytorch torchvision torchaudio -c pytorch ``` #### Instalación con Pip ``` pip install torch torchvision torchaudio ``` ### Conceptos básicos #### Tensores Los tensores son similares a los arrays NumPy, pero pueden ejecutarse en GPUs. ```python import torch # Inicializar un tensor data = [[1, 2],[3, 4]] x_data = torch.tensor(data) # Tensor de NumPy import numpy as np np_array = np.array(data) x_np = torch.from_numpy(np_array) # Tensor de unos x_ones = torch.ones_like(x_data) # retains the properties of x_data print(f"Ones Tensor: \n {x_ones} \n") # Tensor aleatorio x_rand = torch.rand_like(x_data, dtype=torch.float) # overrides the datatype of x_data print(f"Random Tensor: \n {x_rand} \n") # Forma del tensor shape = (2,3,) rand_tensor = torch.rand(shape) ones_tensor = torch.ones(shape) zeros_tensor = torch.zeros(shape) print(f"Random Tensor: \n {rand_tensor} \n") print(f"Ones Tensor: \n {ones_tensor} \n") print(f"Zeros Tensor: \n {zeros_tensor}") # Atributos del tensor tensor = torch.rand(3,4) print(f"Shape of tensor: {tensor.shape}") print(f"Datatype of tensor: {tensor.dtype}") print(f"Device tensor is stored on: {tensor.device}") # Operaciones con tensores # We move our tensor to the GPU if available if torch.cuda.is_available(): tensor = tensor.to("cuda") print(f"Device tensor is stored on: {tensor.device}") # Indexación y segmentación tensor = torch.ones(4, 4) tensor[:,1] = 0 print(tensor) # Unir tensores t1 = torch.cat([tensor, tensor, tensor], dim=1) print(t1) # Aritmética de tensores # This computes the matrix multiplication between two tensors. y1, y2, y3 will have the same value y1 = tensor @ tensor.T y2 = tensor.matmul(tensor.T) y3 = torch.rand_like(y1) torch.matmul(tensor, tensor.T, out=y3) # This computes the element-wise product. z1, z2, z3 will have the same value z1 = tensor * tensor z2 = tensor.mul(tensor) z3 = torch.rand_like(tensor) torch.mul(tensor, tensor, out=z3) # Tensores de puente con NumPy # Tensor a array NumPy t = torch.ones(5) print(f"t: {t}") n = t.numpy() print(f"n: {n}") # Cambios en el tensor que se reflejan en el array NumPy t.add_(1) print(f"t: {t}") print(f"n: {n}") # Array NumPy a tensor n = np.ones(5) t = torch.from_numpy(n) # Cambios en el array NumPy que se reflejan en el tensor np.add(n, 1, out=n) print(f"t: {t}") print(f"n: {n}") ``` ### Conjuntos de datos y cargadores de datos `torch.utils.data.Dataset` almacena las muestras y sus etiquetas correspondientes, y `torch.utils.data.DataLoader` envuelve un iterable sobre el Dataset para permitir un fácil acceso a las muestras. ```python import torch from torch.utils.data import Dataset from torchvision import datasets from torchvision.transforms import ToTensor import matplotlib.pyplot as plt # Descargar el conjunto de datos training_data = datasets.FashionMNIST( root="data", train=True, download=True, transform=ToTensor() ) test_data = datasets.FashionMNIST( root="data", train=False, download=True, transform=ToTensor() ) # Iterar y visualizar el conjunto de datos labels_map = { 0: "T-Shirt", 1: "Trouser", 2: "Pullover", 3: "Dress", 4: "Coat", 5: "Sandal", 6: "Shirt", 7: "Sneaker", 8: "Bag", 9: "Ankle Boot", } figure = plt.figure(figsize=(8, 8)) cols, rows = 3, 3 for i in range(1, cols * rows + 1): sample_idx = torch.randint(len(training_data), size=(1,)).item() img, label = training_data[sample_idx] figure.add_subplot(rows, cols, i) plt.title(labels_map[label]) plt.axis("off") plt.imshow(img.squeeze(), cmap="gray") plt.show() # Crear un cargador de datos from torch.utils.data import DataLoader batch_size = 64 train_dataloader = DataLoader(training_data, batch_size=batch_size) test_dataloader = DataLoader(test_data, batch_size=batch_size) # Iterar a través del DataLoader # Display image and label. train_features, train_labels = next(iter(train_dataloader)) print(f"Feature batch shape: {train_features.size()}") print(f"Labels batch shape: {train_labels.size()}") img = train_features.squeeze() label = train_labels plt.imshow(img, cmap="gray") plt.show() print(f"Label: {label}") # Crear un conjunto de datos personalizado import os import pandas as pd from torchvision.io import read_image class CustomImageDataset(Dataset): def __init__(self, annotations_file, img_dir, transform=None, target_transform=None): self.img_labels = pd.read_csv(annotations_file) self.img_dir = img_dir self.transform = transform self.target_transform = target_transform def __len__(self): return len(self.img_labels) def __getitem__(self, idx): img_path = os.path.join(self.img_dir, self.img_labels.iloc[idx, 0]) image = read_image(img_path) label = self.img_labels.iloc[idx, 1] if self.transform: image = self.transform(image) if self.target_transform: label = self.target_transform(label) return image, label ``` ### Transformaciones Las transformaciones se utilizan para manipular los datos para que sean adecuados para el entrenamiento. ```python import torch from torchvision import datasets from torchvision.transforms import ToTensor, Lambda # Transformaciones ds = datasets.FashionMNIST( root="data", train=True, download=True, transform=ToTensor(), target_transform=Lambda(lambda y: torch.zeros(10, dtype=torch.float).scatter_(dim=0, index=torch.tensor(y), value=1)) ) ``` ### Construir modelos ```python import os import torch from torch import nn from torch.utils.data import DataLoader from torchvision import datasets, transforms # Obtener el dispositivo para el entrenamiento device = "cuda" if torch.cuda.is_available() else "cpu" print(f"Using {device} device") # Definir la clase class NeuralNetwork(nn.Module): def __init__(self): super(NeuralNetwork, self).__init__() self.flatten = nn.Flatten() self.linear_relu_stack = nn.Sequential( nn.Linear(28*28, 512), nn.ReLU(), nn.Linear(512, 512), nn.ReLU(), nn.Linear(512, 10) ) def forward(self, x): x = self.flatten(x) logits = self.linear_relu_stack(x) return logits model = NeuralNetwork().to(device) print(model) # Optimizar el modelo learning_rate = 1e-3 batch_size = 64 loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate) # Bucle de entrenamiento def train(dataloader, model, loss_fn, optimizer): size = len(dataloader.dataset) model.train() for batch, (X, y) in enumerate(dataloader): X, y = X.to(device), y.to(device) # Predicción de error de cálculo pred = model(X) loss = loss_fn(pred, y) # Propagación inversa optimizer.zero_grad() loss.backward() optimizer.step() if batch % 100 == 0: loss, current = loss.item(), batch * len(X) print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]") # Bucle de prueba def test(dataloader, model, loss_fn): size = len(dataloader.dataset) num_batches = len(dataloader) model.eval() test_loss, correct = 0, 0 with torch.no_grad(): for X, y in dataloader: X, y = X.to(device), y.to(device) pred = model(X) test_loss += loss_fn(pred, y).item() correct += (pred.argmax(1) == y).type(torch.float).sum().item() test_loss /= num_batches correct /= size print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n") # Ejecutar el proceso de entrenamiento epochs = 5 for t in range(epochs): print(f"Epoch {t+1}\n-------------------------------") train(train_dataloader, model, loss_fn, optimizer) test(test_dataloader, model, loss_fn) print("Done!") # Guardar el modelo torch.save(model.state_dict(), "model.pth") print("Saved PyTorch Model State to model.pth") # Cargar el modelo model = NeuralNetwork() model.load_state_dict(torch.load("model.pth")) # Usar el modelo para hacer predicciones classes = [ "T-shirt/top", "Trouser", "Pullover", "Dress", "Coat", "Sandal", "Shirt", "Sneaker", "Bag", "Ankle boot", ] model.eval() x, y = test_data, test_data with torch.no_grad(): pred = model(x) predicted, actual = classes[pred.argmax(0)], classes[y] print(f'Predicted: "{predicted}", Actual: "{actual}"') ``` ### Guardar y cargar el modelo ```python import torch import torchvision.models as models # Guardar y cargar model = models.vgg16(pretrained=True) torch.save(model.state_dict(), 'model.pth') model = models.vgg16() # we do not specify pretrained=True, i.e. do not load default weights model.load_state_dict(torch.load('model.pth')) model.eval() ```