El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Aprenentatge per Transferència amb Models Preentrenats

Següent ►
►

Introducció

L'aprenentatge per transferència és una tècnica poderosa en la qual un model preentrenat en una gran base de dades es reutilitza per a una tasca diferent però relacionada. Aquesta tècnica és especialment útil quan no es disposa d'una gran quantitat de dades per entrenar un model des de zero. En aquest mòdul, aprendrem com utilitzar models preentrenats en PyTorch per a tasques de classificació d'imatges.

Objectius

  • Entendre el concepte d'aprenentatge per transferència.
  • Aprendre a carregar models preentrenats en PyTorch.
  • Adaptar un model preentrenat per a una nova tasca.
  • Entrenar i avaluar el model adaptat.

Contingut

  1. Què és l'Aprenentatge per Transferència?
  2. Carregant Models Preentrenats en PyTorch
  3. Adaptant el Model per a una Nova Tasca
  4. Entrenament i Avaluació
  5. Exercici Pràctic

Què és l'Aprenentatge per Transferència?

L'aprenentatge per transferència implica utilitzar un model que ha estat entrenat en una gran base de dades (com ImageNet) i adaptar-lo per a una tasca específica. Els avantatges inclouen:

  • Reducció del temps d'entrenament: Els models preentrenats ja han après característiques útils que es poden reutilitzar.
  • Millor rendiment amb menys dades: Els models preentrenats poden generalitzar millor amb menys dades específiques de la tasca.

Carregant Models Preentrenats en PyTorch

PyTorch proporciona una varietat de models preentrenats a través del mòdul torchvision.models. A continuació, es mostra com carregar un model preentrenat:

import torch
import torchvision.models as models

# Carregar un model preentrenat (per exemple, ResNet18)
model = models.resnet18(pretrained=True)

Adaptant el Model per a una Nova Tasca

Per adaptar un model preentrenat a una nova tasca, normalment es substitueix la capa de sortida per una que s'ajusti al nombre de classes de la nova tasca. Per exemple, si estem treballant amb una tasca de classificació de 10 classes, podem fer el següent:

import torch.nn as nn

# Nombre de classes de la nova tasca
num_classes = 10

# Substituir la capa de sortida
model.fc = nn.Linear(model.fc.in_features, num_classes)

Entrenament i Avaluació

Un cop el model ha estat adaptat, es pot entrenar i avaluar de la mateixa manera que un model entrenat des de zero. A continuació es mostra un exemple de bucle d'entrenament:

# Definir la pèrdua i l'optimitzador
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

# Bucle d'entrenament
num_epochs = 5
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}")

# Avaluació
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print(f"Accuracy: {100 * correct / total}%")

Exercici Pràctic

Objectiu

Utilitzar un model preentrenat (ResNet18) per a una tasca de classificació d'imatges amb 10 classes.

Passos

  1. Carregar el model preentrenat.
  2. Substituir la capa de sortida per una que tingui 10 classes.
  3. Entrenar el model amb un conjunt de dades de classificació d'imatges.
  4. Avaluar el rendiment del model.

Solució

import torch
import torchvision.models as models
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# Transformacions per al conjunt de dades
transform = transforms.Compose([
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
])

# Carregar el conjunt de dades
train_dataset = datasets.FakeData(transform=transform)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

test_dataset = datasets.FakeData(transform=transform)
test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)

# Carregar el model preentrenat
model = models.resnet18(pretrained=True)

# Substituir la capa de sortida
num_classes = 10
model.fc = nn.Linear(model.fc.in_features, num_classes)

# Definir la pèrdua i l'optimitzador
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Bucle d'entrenament
num_epochs = 5
for epoch in range(num_epochs):
    model.train()
    running_loss = 0.0
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
    print(f"Epoch {epoch+1}, Loss: {running_loss/len(train_loader)}")

# Avaluació
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in test_loader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()
print(f"Accuracy: {100 * correct / total}%")

Conclusió

En aquest mòdul, hem après com utilitzar l'aprenentatge per transferència amb models preentrenats en PyTorch. Hem vist com carregar un model preentrenat, adaptar-lo per a una nova tasca, i entrenar-lo i avaluar-lo. Aquesta tècnica és molt útil per millorar el rendiment i reduir el temps d'entrenament quan es disposa de dades limitades.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats