Я работаю над заданием для инфрагционного обучения, и у меня есть только 4000 пар изображений с использованием Resnet-18. Это довольно мало, и у меня есть графический процессор A100-80GB, работающий на сервере. P> Я узнал, что для IMG1, IMG2, метка в DataLoader: Это для строки цикла займет 2 минуты, прежде чем она фактически начнет цикл (пожалуйста, проверьте время напечатано).
Мой вопрос: во время каждой эпохи, когда компьютер сначала запускает строку для IMG1, IMG2, метки в DataLoader: , предварительно ли он предварительно обрабатывать алгоритм в моем классе данных? И это нужно повторить один раз для каждой эпохи? < /P>
ps. batch_size = 128 только займет 10 ГБ моего VRAM, я попробовал num_workers от 0,4,8 ... 32. Небольшая задача может быть выполнена за считанные секунды, если я просто подтолкнула размер партии до предела моего VRAM, но, по -видимому, не тот VRAM, который замедляет скорость. Я чувствую, что это что -то в отношении DataLoader и Num_workers . В моем персональном компьютере, а не на сервере, он всегда был настройка num_workers = 0 и пробовать разные размеры пакета
def train(img_dir):
transform = T.Compose([
T.Resize((224, 224)), # Typical input size for ResNet
T.ToTensor()
])
dataset = ContrastiveDataset(img_dir, transform=transform)
dataloader = DataLoader(dataset, batch_size=128, shuffle=True, num_workers=32)
print(f"Loaded {len(dataset)} image pairs")
model = Resnet18EmbeddingNet(embedding_dim=64).to(device)
model.train()
print(model)
print('-'*20)
print('running model:')
# criterion = ContrastiveLoss(margin=1.0)
criterion = InfoNCELoss(temperature=0.07)
optimizer = optim.Adam(model.parameters(), lr=1e-4)
c = 0
print('right before training start starting time', datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
for epoch in range(10):
total_loss = 0.0
print('Begin of each epoch, current time', datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
for img1, img2, label in dataloader:
print('time for each batch', datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
if c==0:
print(img1.shape)
c+=1
optimizer.zero_grad()
# Move data to device
img1 = img1.to(device)
img2 = img2.to(device)
label = label.to(device)
# Forward pass
out1 = model(img1)
out2 = model(img2)
# Compute loss
# loss = criterion(out1, out2, label) # Contrastive loss
loss = criterion(out1, out2) # InfoNCE loss
loss.backward()
optimizer.step()
total_loss += loss.item() * img1.size(0)
avg_loss = total_loss / len(dataset)
print(f"Epoch [{epoch+1}], Loss: {avg_loss:.4f}")
< /code>
running model:
Timer 1: Begin of each epoch, current time 2025-01-29 22:57:54
Timer2: time for each batch 2025-01-29 22:59:41
torch.Size([128, 3, 224, 224])
Timer2: time for each batch 2025-01-29 22:59:41
Timer2: time for each batch 2025-01-29 22:59:41
Timer2: time for each batch 2025-01-29 22:59:42
< /code>
The codes for my dataset class, I don't think they involve any complicated calculation
class ContrastiveDataset(Dataset):
def __init__(self, img_dir, transform=None):
"""
img_dir: directory containing images named like
"3dmodelimage_hour6_row0_col1.png"
transform: optional torchvision transforms
"""
self.img_dir = img_dir
self.transform = transform
# Gather all .png files
self.image_paths = sorted([
f for f in os.listdir(img_dir) if f.lower().endswith(".png")
])
# For each image, parse the hour and class identity (rowX_colY)
# We'll store a list of (filename, hour, rowcol_class)
self.samples = []
for f in self.image_paths:
# Example filename: "3dmodelimage_hour6_row0_col1.png"
# Extract the hour number (e.g. 6 from "hour6")
hour_match = re.search(r'hour(\d+)', f)
if hour_match:
hour = int(hour_match.group(1))
else:
raise ValueError(f"Could not find 'hour' pattern in filename: {f}")
# Extract the row-col pattern (row\d+_col\d+)
# E.g. "row0_col1" from "row0_col1.png"
rowcol_match = re.search(r'(row\d+_col\d+)', f)
if rowcol_match:
rowcol_class = rowcol_match.group(1) # e.g. "row0_col1"
else:
raise ValueError(f"Could not find row-col pattern in filename: {f}")
self.samples.append((f, hour, rowcol_class))
# Build list of (index1, index2, label) pairs:
# * Pairs only among images with the same rowcol_class
# * label=1 if hour diff == 1, else 0
self.pairs = []
for i in range(len(self.samples)):
for j in range(i+1, len(self.samples)):
f_i, hour_i, class_i = self.samples
f_j, hour_j, class_j = self.samples[j]
# Only compare if the rowcol_class is the same
if class_i == class_j:
label = 1 if abs(hour_i - hour_j) == 1 else 0
self.pairs.append((i, j, label))
def __len__(self):
# Total number of pairs
return len(self.pairs)
def __getitem__(self, idx):
i, j, label = self.pairs[idx]
# Retrieve the sample info
filename_i, _, _ = self.samples
filename_j, _, _ = self.samples[j]
# print('-'*20)
# print(filename_i)
# print(filename_j)
# Full paths
path_i = os.path.join(self.img_dir, filename_i)
path_j = os.path.join(self.img_dir, filename_j)
# Open and transform
img_i = Image.open(path_i).convert("RGB")
img_j = Image.open(path_j).convert("RGB")
if self.transform:
img_i = self.transform(img_i)
img_j = self.transform(img_j)
return img_i, img_j, torch.tensor(label, dtype=torch.float32)
Подробнее здесь: https://stackoverflow.com/questions/793 ... ader-speed
