Change 3 channel to 1 channel

username: buinhatquan
cooked: <p>Here is my code and my error picture</p>
<p><div class="lightbox-wrapper"><a class="lightbox" href="https://discuss.pytorch.org/uploads/default/original/2X/f/f441b9f8714e0c4498feb7047ee533b4758d9dab.png" data-download-href="https://discuss.pytorch.org/uploads/default/f441b9f8714e0c4498feb7047ee533b4758d9dab" title="error"><img src="https://discuss.pytorch.org/uploads/default/original/2X/f/f441b9f8714e0c4498feb7047ee533b4758d9dab.png" alt="error" data-base62-sha1="yQNjU7Y8l3tBJXHF0HglJ55aXLZ" width="690" height="180" data-dominant-color="F9F9FA"><div class="meta"><svg class="fa d-icon d-icon-far-image svg-icon" aria-hidden="true"><use href="#far-image"></use></svg><span class="filename">error</span><span class="informations">1291×337 13 KB</span><svg class="fa d-icon d-icon-discourse-expand svg-icon" aria-hidden="true"><use href="#discourse-expand"></use></svg></div></a></div></p>
<pre data-code-wrap="python"><code class="lang-python">%cd
!mkdir -p /root/data
%cd /root/data
!pip install -q -U opencv-python
!pip install -q pandas
!pip install numpy==1.15.0
!pip install torch
!pip3 install torchvision
!pip install --upgrade torch torchvision

from google.colab import drive
drive.mount('/content/gdrive')

import os
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
import torch.utils.data as data
import torchvision
from torchvision import transforms
import cv2
from matplotlib import pyplot as plt
import torch.optim as optim

from google.colab import files
uploaded = files.upload()

items = os.listdir('/content')
print (items) 

for each_image in items:
  if each_image.endswith(".jpg"):
    print (each_image)
    full_path = "/content/" + each_image
    dest_path = "/root/data/" + each_image
    print (full_path)
    image = cv2.imread(full_path)
    im_gray = cv2.cvtColor(image,cv2.COLOR_BGR2RGB)
    im_blur=cv2.GaussianBlur(im_gray,(5,5),0)
    im,thre=cv2.threshold(im_blur,180,255,cv2.THRESH_BINARY_INV) 
    thre2=cv2.resize(thre,(28,28),interpolation=cv2.INTER_AREA)
    plt.subplot(2,3,6)
    plt.tight_layout()  
    plt.imshow(thre2)
    plt.xticks([])
    plt.yticks([])
    plt.show()  
    cv2.imwrite(dest_path,thre2)

!pip install -U -q PyDrive

from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive
from google.colab import auth
from oauth2client.client import GoogleCredentials

# 1. Authenticate and create the PyDrive client.
auth.authenticate_user()
gauth = GoogleAuth()
gauth.credentials = GoogleCredentials.get_application_default()
drive = GoogleDrive(gauth)

from googleapiclient.http import MediaFileUpload
from googleapiclient.discovery import build
drive_service = build('drive','v3')

def save_file_to_drive(name,path):
  file_metadata={
      'name':name,
      'mimeType': 'application/octet-stream'
  }
  media= MediaFileUpload(path,mimetype='application/octet-stream',resumable=True)
  created=drive_service.files().create(body=file_metadata,media_body=media,fields='id').execute()
  return created


import zipfile
!zip -r /root/image.zip  /root/data

 save_file_to_drive('image.zip','/root/image.zip')


n_epochs=3
batch_size_train=32
batch_size_test=89
learning_rate=0.01
momentum=0.5
log_interval=10

random_seed=1
torch.backends.cudnn.enabled=False
torch.manual_seed(random_seed)

data_transforms = transforms.Compose([    
    transforms.Resize(256),
    transforms.CenterCrop(256),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225] )])

%cd /content/gdrive/'My Drive'/root/data

train_datasets = torchvision.datasets.ImageFolder(root= "/content/gdrive/My Drive/root/", transform=data_transforms)

import torch.utils.data as data
train_data_loader = data.DataLoader(train_datasets, batch_size=batch_size_train, shuffle=True,  num_workers=4)
test_data = torchvision.datasets.ImageFolder(root="/content/gdrive/My Drive/root/", transform=data_transforms)
test_data_loader = data.DataLoader(test_data, batch_size=batch_size_test, shuffle=True, num_workers=4)

examples=enumerate(test_data_loader)
batch_idx, (example_data, example_targets) = next(examples)

import matplotlib.pyplot as plt

fig = plt.figure()
for i in range(12):
  plt.subplot(3,4,i+1)
  plt.tight_layout()
  plt.imshow(example_data[i][0], cmap='gray', interpolation='none')
  plt.title("Ground Truth: {}".format(example_targets[i]))
  plt.xticks([])
  plt.yticks([])
fig

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(1, 10, kernel_size=5)
        self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
        self.conv2_drop = nn.Dropout2d()
        self.fc1 = nn.Linear(320, 50)
        self.fc2 = nn.Linear(50, 10)

    def forward(self, x):
        x = F.relu(F.max_pool2d(self.conv1(x), 2))
        x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))
        x = x.view(-1, 320)
        x = F.relu(self.fc1(x))
        x = F.dropout(x, training=self.training)
        x = self.fc2(x)
        return F.log_softmax(x)

network = Net()
optimizer = optim.SGD(network.parameters(), lr=learning_rate,
                      momentum=momentum)

train_losses = []
train_counter = []
test_losses = []
test_counter = [i*len(train_data_loader.dataset) for i in range(n_epochs + 1)]

def train(n_epochs):
  network.train()
  for batch_idx, (data, target) in enumerate(train_data_loader):
    optimizer.zero_grad()
    output = network(data)
    loss = F.nll_loss(output, target)
    loss.backward()
    optimizer.step()
    if batch_idx % log_interval == 0:
      print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
        n_epochs, batch_idx * len(data), len(train_data_loader.dataset),
        100. * batch_idx / len(train_data_loader), loss.item()))
      train_losses.append(loss.item())
      train_counter.append((batch_idx*64) + ((n_epochs-1)*len(train_data_loader.dataset)))
      torch.save(network.state_dict(), 'model.pth')
      torch.save(optimizer.state_dict(), 'optimizer.pth')

def test():
  network.eval()
  test_loss = 0
  correct = 0
  with torch.no_grad():
    for data, target in test_data_loader:
      output = network(data)
      test_loss += F.nll_loss(output, target, size_average=False).item()
      pred = output.data.max(1, keepdim=True)[1]
      correct += pred.eq(target.data.view_as(pred)).sum()
  test_loss /= len(test_data_loader.dataset)
  test_losses.append(test_loss)
  print('\nTest set: Avg. loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
    test_loss, correct, len(test_data_loader.dataset),
    100. * correct / len(test_data_loader.dataset)))

test()
for n_epochs in range(1, n_epochs + 1):
  train(n_epochs)
  test()
</code></pre>

username: ptrblck
cooked: <p>You could set <code>in_channels=3</code> for <code>self.conv1</code> or alternatively convert your images to grayscale using:</p>
<pre><code class="lang-python">data_transforms = transforms.Compose([
    transforms.Grayscale(num_output_channels=1),
    transforms.Resize(256),
    transforms.CenterCrop(256),
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406],
                         std=[0.229, 0.224, 0.225] )])
</code></pre>
<p>PS: I’ve formatted your code for better readability. You can add code snippets using three backticks ``` <img src="https://discuss.pytorch.org/images/emoji/apple/wink.png?v=9" title=":wink:" class="emoji" alt=":wink:"></p>

username: Ab_Niazi
cooked: <aside class="quote no-group" data-username="ptrblck" data-post="2" data-topic="46619">
<div class="title">
<div class="quote-controls"></div>
<img loading="lazy" alt="" width="24" height="24" src="https://discuss.pytorch.org/user_avatar/discuss.pytorch.org/ptrblck/48/1823_2.png" class="avatar"> ptrblck:</div>
<blockquote>
<p><code>transforms.Grayscale(num_output_channels=1),</code></p>
</blockquote>
</aside>
<p>If we want to change the 3 channel image in to 1 channel .  dont we have to normalize into only in one channel rather then three channel<br>
transforms.Normalize(mean=[0.485, 0.456, 0.406],<br>
std=[0.229, 0.224, 0.225] )])</p>
<p>it should be</p>
<p>transforms.Normalize(mean=[0.485],<br>
std=[0.229] )])</p>

username: ptrblck
cooked: <p>Yes, you are right and the <code>Normalize</code> transformation expects a single value for both stats.</p>

username: Ab_Niazi
cooked: <p>Dear <a class="mention" href="/u/ptrblck">@ptrblck</a>  Thank you for the confirmation</p>