I got Issue while predicting the images?

[emadyounan]

I'm using my own black and white tiff images dataset and I created the model_0 as the videos I will put my code That's that the error I got

"Given groups=1, weight of size [10, 3, 3, 3], expected input[1, 1, 128, 128] to have 3 channels, but got 1 channels instead"

here is the full code:

# Create simple transform

simple_transform = transforms.Compose([
    transforms.Resize(size=(128, 128)),
    transforms.ToTensor()
])

# Load data and transform data

train_data_simple = datasets.ImageFolder(root=train_dir,
                                          transform=simple_transform)

test_data_simple = datasets.ImageFolder(root=test_dir,
                                          transform=simple_transform)

# Turn dataset into DataLoader

BATCH_SIZE = 32
NUM_WORKERS = 2

train_dataloader_simple = DataLoader(dataset=train_data_simple,
                                     batch_size=BATCH_SIZE,
                                     num_workers=NUM_WORKERS,
                                     shuffle=True)

test_dataloader_simple = DataLoader(dataset=test_data_simple,
                                     batch_size=BATCH_SIZE,
                                     num_workers=NUM_WORKERS,
                                     shuffle=False)


class TingVGG(nn.Module):
    def __init__(self, input_shape: int, hidden_units: int, output_shape: int) -> None:
        super().__init__()
        self.conv_block1 = nn.Sequential(nn.Conv2d(in_channels=input_shape,out_channels=hidden_units,kernel_size=3,stride=1,padding=0),
        nn.ReLU(),
        nn.Conv2d(in_channels=hidden_units, out_channels=hidden_units, kernel_size=3,stride=1,padding=0),
        nn.ReLU(),
        nn.MaxPool2d(kernel_size=2, stride=2)
        )
        
        self.conv_block2 = nn.Sequential(nn.Conv2d(in_channels=hidden_units,out_channels=hidden_units,kernel_size=3,stride=1,padding=0),
        nn.ReLU(),
        nn.Conv2d(in_channels=hidden_units, out_channels=hidden_units, kernel_size=3,stride=1,padding=0),
        nn.ReLU(),
        nn.MaxPool2d(kernel_size=2, stride=2)
        )
        
        self.classifier = nn.Sequential(nn.Flatten(), nn.Linear(in_features=hidden_units *29*29,out_features=output_shape))
        
        
    def forward(self, x: torch.Tensor):
        x = self.conv_block1(x)
        #print(x.shape)
        x = self.conv_block2(x)
        #print(x.shape)
        x = self.classifier(x)
        #print(x.shape)
        return x
        #return self.classifier(self.conv_block2(self.conv_block1(x))) # benefits from the operator fusion


torch.manual_seed(42)
model_0 = TingVGG(input_shape=3, # Number of channels in the input image (c, h, w) -> 3
                  hidden_units=10,
                  output_shape=len(train_data.classes)).to(device)
model_0


# Try forward pass
model_0(image_batch.to(device))


# Create train_step function

def train_step(model: torch.nn.Module,
               dataloader: DataLoader,
               loss_fn: torch.nn.Module,
               optimizer: torch.optim.Optimizer,
               device=device
               ):
    # put the model into the train
    model.train()
    
    # Setup train loss and train accuracy values
    train_loss, train_acc = 0, 0
    
    # Loop through DataLoader and data batches
    for batch, (X, y) in enumerate(dataloader):
         # Send data to the target device
         X, y = X.to(device), y.to(device)
         
         # 1. forward pass
         y_pred = model(X) #output model logits
         
         # 2. Calculate the loss
         loss = loss_fn(y_pred, y)
         train_loss += loss.item()
         
         # 3. Optimize zero grad
         optimizer.zero_grad()
         
         # 4.Loss backward
         loss.backward()
         
         # 5.Optimzer step
         optimizer.step()
         
         # Calculate the accuracy metric
         y_pred_class = torch.argmax(torch.softmax(y_pred, dim=1), dim=1)
         train_acc += (y_pred_class ==y).sum().item()/len(y_pred)
    
    # Adjust metrics to get average loss and accuracy per batch
    train_loss = train_loss / len(dataloader)
    train_acc = train_acc / len(dataloader)
    return train_loss, train_acc


# Create test_step function

def test_step(model: torch.nn.Module,
               dataloader: DataLoader,
               loss_fn: torch.nn.Module,
               device=device
               ):
    # Put the model in eval mode
    model.eval()
    
    # Setup train loss and train accuracy values
    test_loss, test_acc = 0, 0
    
    # Turn on inference mode
    with torch.inference_mode():
        # Loop through DataLoader Batches
        for batch, (X, y) in enumerate(dataloader):
            # Send data to the target device
            X, y = X.to(device), y.to(device)
            
            # 1. forward pass
            test_pred_logits = model(X)
            
            # 2. Calculate the loss
            loss = loss_fn(test_pred_logits, y)
            test_loss += loss.item()
            
            # 3. Calculate the accuracy
            test_pred_labels = test_pred_logits.argmax(dim=1)
            test_acc += ((test_pred_labels == y).sum().item() / len(test_pred_labels))
            
    # Adjust metrics to get average loss and accuracy per batch
    test_loss = test_loss / len(dataloader)
    test_acc = test_acc / len(dataloader)
    return test_loss, test_acc


# 1. Create function that takes in various model parameters and optimizer + dataloader + loss function

def train(model: torch.nn.Module,
          train_dataloader: DataLoader,
          test_dataloader: DataLoader,
          optimizer: torch.optim.Optimizer,
          loss_fn: torch.nn.Module = nn.CrossEntropyLoss(),
          epochs: int = 10,
          device = device):
    # 2. Create empty results dictionary
    results = {"train_loss": [],
               "train_acc": [],
               "test_loss": [],
               "test_acc": []}
    
    # 3. Loop through training and testing steps for a number of epochs
    for epoch in tqdm(range(epochs)):
        train_loss, train_acc = train_step(model= model, dataloader= train_dataloader,loss_fn=loss_fn, optimizer=optimizer, device=device)
        test_loss, test_acc = test_step(model= model, dataloader=test_dataloader,loss_fn=loss_fn, device=device)
        
        # 4. Print out what's happening
        print(f"Epoch: {epoch +1} | "
            f"train_loss: {train_loss:.4f} | "
            f"train_acc: {train_acc:.4f} | "
            f"test_loss: {test_loss:.4f} | "
            f"test_acc: {test_acc:.4f}")
        
        # 5. Update the results dictionary
        results["train_loss"].append(train_loss)
        results["train_acc"].append(train_acc)
        results["test_loss"].append(test_loss)
        results["test_acc"].append(test_acc)
        
    # 6. return the results at the end of the epoches
    return results


# Set random seed
torch.manual_seed(42)
torch.cuda.manual_seed(42)

# Set number of epoches
NUM_EPOCHS = 20

# Create and initialize of TinyVGG
model_0 = TingVGG(input_shape=3, # Number of channels in the input image (c, h, w) -> 3
                  hidden_units=10,
                  output_shape=len(train_data.classes)).to(device)

# Setup the loss function and optimizer
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(params= model_0.parameters(),
                             lr= 0.001)

# Start the timer
start_time = timer()

# Train model 0
model_0_results = train(model= model_0,
                        train_dataloader= train_dataloader_simple,
                        test_dataloader= test_dataloader_simple,
                        optimizer= optimizer,
                        loss_fn= loss_fn,
                        epochs= NUM_EPOCHS
                        )

# End the timer and print the results
end_time = timer()
print(f"Total training time: {end_time - start_time: .3f} seconds")


import torchvision.transforms.functional as transform
import PIL

# Reads a file using pillow
PIL_image = PIL.Image.open(custom_image_path)

# The image can be converted to tensor using
tensor_image = transform.to_tensor(PIL_image)

# The tensor can be converted back to PIL using
new_PIL_image = transform.to_pil_image(tensor_image)

# Divide the image pixel values by 255 to get them between [0, 1]
tensor_image = tensor_image / 255. 

# Print out image data
print(f"Custom image tensor:\n{tensor_image}\n")
print(f"Custom image shape: {tensor_image.shape}\n")
print(f"Custom image dtype: {tensor_image.dtype}")


# Create transform pipleine to resize image
custom_image_transform = transforms.Compose([
    transforms.Resize((128, 128)),
])

# Transform target image
custom_image_transformed = custom_image_transform(tensor_image)

# Print out original shape and new shape
print(f"Original shape: {tensor_image.shape}")
print(f"New shape: {custom_image_transformed.shape}")


model_0.eval()
with torch.inference_mode():
    # Add an extra dimension to image
    custom_image_transformed_with_batch_size = custom_image_transformed.unsqueeze(dim=0)
    
    # Print out different shapes
    print(f"Custom image transformed shape: {custom_image_transformed.shape}")
    print(f"Unsqueezed custom image shape: {custom_image_transformed_with_batch_size.shape}")
    
    # Make a prediction on image with an extra dimension
    custom_image_pred = model_0(custom_image_transformed_with_batch_size.to(device))  ## here is the error

[mrdbourke]

Hi @emadyounan,

Looks like you're trying to use black and white images (1 colour channel) with a model that accepts colour images (3 colour channels).

I'd look into your model definition to adjust it to work with black and white images.

See your own image data shape is: [1, 1, 128, 128]

But the model expects: [10, 3, 3, 3]

You can try changing this behaviour here:

# Create and initialize of TinyVGG
model_0 = TingVGG(input_shape=3, # Number of channels in the input image (c, h, w) -> 3
                  hidden_units=10,
                  output_shape=len(train_data.classes)).to(device)