es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

PyTorch: omitir el cálculo de características de modelos preentrenados en cada época.

12 Jul, 2023 Programación

Estoy acostumbrado a trabajar con TensorFlow – Keras, pero ahora me veo obligado a empezar a trabajar con Pytorch por cuestiones de flexibilidad. Sin embargo, no logro encontrar un código en Pytorch que se centre únicamente en entrenar la capa de clasificación de un modelo. ¿No es eso una práctica común? Ahora tengo que esperar al cálculo de la extracción de características de los mismos datos para cada época. ¿Hay alguna forma de evitar eso?

# en tensorflow - keras:
from tensorflow.keras.applications import vgg16, MobileNetV2, mobilenet_v2

# Cargar un modelo pre-entrenado
pretrained_nn = MobileNetV2(weights='imagenet', include_top=False, input_shape=(tamaño_imagen, tamaño_imagen, 3))

# Extraer características solo una vez de los datos de entrenamiento
X = mobilenet_v2.preprocess_input(X)
features_x = pretrained_nn.predict(X)

# Guardar características para su uso posterior
joblib.dump(features_x, "caracteristicas_x.dat")

# Crear un modelo y añadir capas
modelo = Sequential()
modelo.add(Flatten(input_shape=features_x.shape[1:]))
modelo.add(Dense(100, activation='relu', use_bias=True))
modelo.add(Dense(Y.shape[1], activation='softmax', use_bias=False))

# Compilar y entrenar solo el modelo completamente conectado
modelo.compile(loss='categorical_crossentropy', optimizer=keras.optimizers.Adam(learning_rate=0.001))
history = modelo.fit(features_x, Y_entrenamiento, batch_size=16, epochs=Epochs)
Tags:  , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    En Pytorch, es una práctica común entrenar solamente la capa de clasificación de un modelo pre-entrenado para el aprendizaje por transferencia. Una forma de evitar el cálculo repetido de la extracción de características en cada época es extraer las características una vez y guardarlas para su uso posterior. Esto se puede lograr utilizando DataLoader y torch.utils.data.Dataset de Pytorch. Aquí tienes un código de ejemplo:

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

class FeaturesDataset(Dataset):
    def __init__(self, dataset, model):
        self.dataset = dataset
        self.model = model

    def __getitem__(self, index):
        x = self.dataset[index][0]
        x = self.model(x.unsqueeze(0))
        return x.squeeze(0)

    def __len__(self):
        return len(self.dataset)

# Cargar el modelo pre-entrenado
pretrained_model = models.resnet18(pretrained=True)
pretrained_model.fc = nn.Identity()

# Crear extractor de características
feature_extractor = nn.Sequential(
    pretrained_model,
    nn.Flatten(),
)

# Extraer características del conjunto de datos de entrenamiento solo una vez
transform = transforms.Compose([
    transforms.Resize(256),
    transforms.CenterCrop(224),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    ),
])

dataset = torchvision.datasets.ImageFolder('path/to/data', transform=transform)
loader = DataLoader(dataset, batch_size=16, num_workers=4)

features = []
with torch.no_grad():
    for batch in loader:
        features.append(feature_extractor(batch))
features_x = torch.cat(features)

# Guardar características para uso posterior
torch.save(features_x, 'features.pt')

# Crear un modelo y agregar capas
model = nn.Sequential(
    nn.Linear(512, 100),
    nn.ReLU(),
    nn.Linear(100, Y.shape[1]),
    nn.Softmax(dim=1),
)

# Cargar características pre-extraídas
features_x = torch.load('features.pt')

# Compilar y entrenar solamente las capas completamente conectadas del modelo
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

for epoch in range(Epochs):
    for x, y in zip(features_x, Y_train):
        optimizer.zero_grad()
        output = model(x)
        loss = criterion(output, y)
        loss.backward()
        optimizer.step()

    En este ejemplo, creamos un conjunto de datos y un DataLoader de Pytorch para cargar y preprocesar los datos, y un FeaturesDataset para extraer características del modelo pre-entrenado. Luego, iteramos sobre el DataLoader para extraer las características una vez y guardarlas en un archivo. Después de eso, creamos un modelo de Pytorch y cargamos las características pre-extraídas, y entrenamos solo las capas completamente conectadas del modelo.

Comments are closed.