Как исправить ValueError: ожидаемый входной размер пакета (49) соответствует целевому размеру пакета (64) ⇐ Python

[Anonymous]

Я продолжаю изменять сторону загрузчика данных, но ошибка по-прежнему отображается.
Это код предварительной обработки:

Код: Выделить всё

import torch
from torch.utils.data import Dataset, DataLoader
from torchvision import transforms

class ImageDataset(Dataset):
def __init__(self, images, labels, transform=None, target_transform=None):
self.images = images
self.labels = labels
self.transform = transform
self.target_transform = target_transform

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

def __getitem__(self, idx):
image = self.images[idx]
label = self.labels[idx]

if self.transform:
image = self.transform(image)

if self.target_transform:
label = self.target_transform(label)

return image, label

# resize the data
resize_transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5,), (0.5,))
])

# using Data Loader, is a function that wraps the Dataset and outputs each data using a mini-batch.
train_dataset = ImageDataset(images=x, labels=y, transform=resize_transform)
train_dataloader = DataLoader(train_dataset, batch_size=64, shuffle=True)

# print each data (x test and y test in dataloader)
for images, labels in train_dataloader:
print(images.shape)
print(labels.shape)
break

а это модель:

Код: Выделить всё

val_dataset = ImageDataset(x_val, y_val, transform=resize_transform)
val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False)

import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

class Network(nn.Module):
def __init__(self):
super(Network, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3)
self.conv2 = nn.Conv2d(32, 64, 3)
self.fc1 = nn.Linear(64 * 16 * 16, 128)
self.fc2 = nn.Linear(128, 64)
self.fc3 = nn.Linear(64, 16)  # Adjusted for 16 classes

self.pool = nn.MaxPool2d(2, 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, 64 * 16 * 16)  # Flatten layer
x = F.relu(self.fc1(x))
x = F.relu(self.fc2(x))
x = self.fc3(x)
return x

# Define the loss function and optimizer
net = Network()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)

# Training the model
num_epochs = 10
for epoch in range(num_epochs):
net.train()
running_loss = 0.0
for i, data in enumerate(train_dataloader, 0):
inputs, labels = data
optimizer.zero_grad()
outputs = net(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()

print(f"Epoch [{epoch + 1}/{num_epochs}], Loss: {running_loss / len(train_dataloader):.4f}")

# Validation accuracy
net.eval()
correct = 0
total = 0
with torch.no_grad():
for inputs, labels in val_loader:
outputs = net(inputs)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()

accuracy = 100 * correct / total
print(f"Validation Accuracy: {accuracy:.2f}%")

print("Finished Training")

asdfefeffffffffffffffffffdsfasfaferwgaergegreagafdgfdgregergagre grarereberba
И эта упомянутая выше ошибка продолжает появляться:

• Добавил всю ошибку

Код: Выделить всё

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
Cell In[11], line 42
40 optimizer.zero_grad()
41 outputs = net(inputs)
---> 42 loss = criterion(outputs, labels)
43 loss.backward()
44 optimizer.step()

File ~\anaconda3\Lib\site-packages\torch\nn\modules\module.py:1736, in Module._wrapped_call_impl(self, *args, **kwargs)
1734     return self._compiled_call_impl(*args, **kwargs)  # type: ignore[misc]
1735 else:
->  1736     return self._call_impl(*args, **kwargs)

File ~\anaconda3\Lib\site-packages\torch\nn\modules\module.py:1747, in Module._call_impl(self, *args, **kwargs)
1742 # If we don't have any hooks, we want to skip the rest of the logic in
1743 # this function, and just call forward.
1744 if not (self._backward_hooks or self._backward_pre_hooks or self._forward_hooks or self._forward_pre_hooks
1745         or _global_backward_pre_hooks or _global_backward_hooks
1746         or _global_forward_hooks or _global_forward_pre_hooks):
-> 1747     return forward_call(*args, **kwargs)
1749 result = None
1750 called_always_called_hooks = set()

File ~\anaconda3\Lib\site-packages\torch\nn\modules\loss.py:1293, in CrossEntropyLoss.forward(self, input, target)
1292 def forward(self, input: Tensor, target: Tensor) -> Tensor:
-> 1293     return F.cross_entropy(
1294         input,
1295         target,
1296         weight=self.weight,
1297         ignore_index=self.ignore_index,
1298         reduction=self.reduction,
1299         label_smoothing=self.label_smoothing,
1300     )

File ~\anaconda3\Lib\site-packages\torch\nn\functional.py:3479, in cross_entropy(input, target, weight, size_average, ignore_index, reduce, reduction, label_smoothing)
3477 if size_average is not None or reduce is not None:
3478     reduction = _Reduction.legacy_get_string(size_average, reduce)
-> 3479 return torch._C._nn.cross_entropy_loss(
3480     input,
3481     target,
3482     weight,
3483     _Reduction.get_enum(reduction),
3484     ignore_index,
3485     label_smoothing,
3486 )

ValueError: Expected input batch_size (49) to match target batch_size (64).

В чем здесь проблема и как ее решить?

Подробнее здесь: https://stackoverflow.com/questions/791 ... batch-size