Hello community 
I am building a model to train a dataset of images 224*224 with a channel 3 RGB using Alexnet cnn network
I am stuck on the below error, if you can please advise how to solve this issue, appreciated your guidance.
Output of my tensors before getting the error:
[[0.70980392 0. 0.03921569 … 0.02745098 0. 0. ]
[0.61568627 0. 0.02352941 … 0.01960784 0. 0. ]
[0.46666667 0.04705882 0. … 0.00784314 0.00392157 0.02745098]
…
[0.41960784 0.42352941 0.22745098 … 0.04705882 0.01568627 0.04705882]
[0.41960784 0.43529412 0.18431373 … 0. 0. 0. ]
[0.41568627 0.43921569 0.15294118 … 0. 0. 0. ]]]
index of the image in get target 20
img shape (3, 224, 224)
The error I am getting is :
RuntimeError: Expected object of scalar type Double but got scalar type Float for argument #3 ‘mat1’ in call to th_addmm
This is my code for the dataloader:
torch.utils.data.Dataset
class Mydataset(Dataset):
def init(self, root, classes, task_num, memory_classes, memory, num_samples_per_class, train, transform= transforms.ToTensor(), target_transform=None, download=True):
self.root = os.path.expanduser(root)
self.transform = transform
self.target_transform = target_transform
self.train = train
self.filename = 'mydataset.zip'
fpath = os.path.join(root, self.filename)
if not os.path.isfile(fpath):
if not download:
raise RuntimeError('Dataset not found. You can use download=True to download it')
else:
print('Downloading from ' + self.url)
download_url(self.url, root, filename=self.filename)
import zipfile
zip_ref = zipfile.ZipFile(fpath, 'r')
zip_ref = zipfile.ZipFile(fpath, 'r')
zip_ref.extractall(root)
zip_ref.close()
if self.train:
fpath = os.path.join(root, 'mydataset', 'train')
else:
fpath = os.path.join(root, 'mydataset', 'val')
#adding mapping
self.class_mapping = {c: i for i, c in enumerate(classes)}
self.class_indices= {}
for cls in classes:
self.class_indices[self.class_mapping[cls]] = []
#image data array
data = []
#class name array
labels = []
tt = [] #task module labels
td = [] #discriminator labels
pop_mean = []
pop_std = []
targets= []
for folder in os.listdir(fpath):
folder_path = os.path.join(fpath, folder)
print("folder path", folder_path)
for ims in os.listdir(folder_path):
try:
img_path = os.path.join(folder_path, ims)
image = np.array(Image.open(img_path))
#image= np.resize(image,(IMG_HEIGHT,IMG_WIDTH,1))
#X.append(np.array(Image.open(img_path))) #.convert('RGB')
#image = ToTensor()(image).unsqueeze(1)
data.append(image)
labels.append(folder)
except:
print("File {}/{} is broken".format(folder, ims))
self.data = np.array(data)
self.targets = labels
self.num_classes = len(set(labels))
for i in range(len(self.data)):
if self.targets[i] in classes:
data.append(self.data[i])
labels.append(self.class_mapping[self.labels[i]])
tt.append(task_num)
td.append(task_num + 1)
self.class_indices[self.class_mapping[self.labels[i]]].append(i)
if memory_classes:
for task_id in range(task_num):
for i in range(len(memory[task_id]['x'])):
if memory[task_id]['y'][i] in range(len(memory_classes[task_id])):
data.append(memory[task_id]['x'][i])
labels.append(memory[task_id]['y'][i])
tt.append(memory[task_id]['tt'][i])
td.append(memory[task_id]['td'][i])
self.data = np.array(data)
self.labels = labels
self.tt = tt
self.td = td
#self.data = self.data.reshape((10000,3,244,244))
self.data = self.data.transpose((0, 3, 1, 2))
if num_samples_per_class:
x, y = [], []
tt, td = [], []
for l in range(self.num_classes): #l from 0 to 25 num_classes is 26 # changed np.array(self.targets) to (self.labels)
indices_with_label_l = np.where(np.array(self.labels)) #== l) # indices with label l = numpy array (target as label array Y [] == value of l from 0 to 25)
x_with_label_l = [self.data[item] for item in indices_with_label_l[0]]
shuffled_indices = np.random.permutation(len(x_with_label_l))[:num_samples_per_class]
x_with_label_l = [x_with_label_l[item] for item in shuffled_indices]
y_with_label_l = [l] * len(shuffled_indices)
x.append(x_with_label_l)
y.append(y_with_label_l)
self.data = np.array(sum(x, []))
self.labels = sum(y, [])
#target_dict = {k: v for v, k in enumerate(np.unique(Y))}
print("data", self.data)
# print("labels", self.labels)
self.tt = [task_num for _ in range(len(self.data))]
self.td = [task_num + 1 for _ in range(len(self.data))
def __getitem__(self, index):
img, target, tt, td = self.data[index], self.labels[index], self.tt[index], self.td[index]
#An error RuntimeError: value cannot be converted to type uint8_t without overflow: -0.00481544-
img = img / 255
#img = Image.fromarray(img).convert(‘RGB’)
#img = self.transform(img)
try:
if self.transform is not None: img= self.transform(img)
except:
pass
try:
if self.target_transform is not None: tt= self.target_transform(tt)
if self.target_transform is not None: td= self.target_transform(td)
except:
pass
return img, target, tt, td
def processed_folder(self):
return os.path.join(self.root, self.__class__.__name__, 'processed')
def __len__(self):
return len(self.data)
class DatasetGen(object):
def __init__(self, args):
super(DatasetGen, self).__init__()
self.seed = args.seed
self.batch_size=args.batch_size
self.pc_valid=args.pc_valid
self.root = args.data_dir
self.latent_dim = args.latent_dim
self.use_memory = args.use_memory
self.num_tasks = args.ntasks
self.num_classes = 25
self.num_samples = args.samples
self.num_samples_per_class = 2
self.inputsize = [3,224,224]
mean = [0.485, 0.456, 0.406]
std = [0.229, 0.224, 0.225]
#transformation compose
self.transformation = transforms.Compose([
transforms.ToTensor(), transforms.Normalize(mean, std)])
#taskcla
self.taskcla = [[t, int(self.num_classes / self.num_tasks)] for t in range(self.num_tasks)]
self.indices = {}
self.dataloaders = {}
self.idx = {}
self.num_workers = args.workers
#i changed the value of pin memory from true to flase to test
self.pin_memory = False ##coda only set to false on cpu
np.random.seed(self.seed)
self.task_ids = [[0,1], [2,3], [4,5], [6,7], [8,9], [10,11], [12,13], [14,15], [16,17], [18,19], [20,21], [22,23], [24,25]]
self.train_set = {}
self.test_set = {}
#task memory
#self.task_memory = [] or
self.task_memory = {}
for i in range(self.num_tasks):
self.task_memory[i] = {}
self.task_memory[i]['x'] = []
self.task_memory[i]['y'] = []
self.task_memory[i]['tt'] = []
self.task_memory[i]['td'] = []
#def get(task_id)
def get(self, task_id):
self.dataloaders[task_id] = {}
sys.stdout.flush()
if task_id == 0:
memory_classes = None
memory = None
else:
memory_classes = self.task_ids
memory = self.task_memory
print(self.task_ids[task_id])
self.train_set[task_id] = mydataset(root=self.root, classes=self.task_ids[task_id],
memory_classes=self.task_ids,
memory=memory, num_samples_per_class= self.num_samples_per_class,task_num=task_id, train=True,
download=False, transform=self.transformation)
self.test_set[task_id] = mydataset(root=self.root, classes=self.task_ids[task_id], memory_classes=self.task_ids,
memory=None, num_samples_per_class= self.num_samples_per_class, task_num=task_id, train=False,
download=False, transform=self.transformation)
split = int(np.floor(self.pc_valid * len(self.train_set[task_id])))
train_split, valid_split = torch.utils.data.random_split(self.train_set[task_id],
[len(self.train_set[task_id]) - split, split])
#update shuffle to false for testing
train_loader = torch.utils.data.DataLoader(train_split, batch_size=self.batch_size,
num_workers=self.num_workers,
pin_memory=self.pin_memory, shuffle=False, drop_last=True)
pop_mean = []
pop_std = []
valid_loader = torch.utils.data.DataLoader(valid_split, batch_size=int(self.batch_size * self.pc_valid),
shuffle=False,
num_workers=self.num_workers, pin_memory=self.pin_memory)
test_loader = torch.utils.data.DataLoader(self.test_set[task_id], batch_size=self.batch_size,
num_workers=self.num_workers,
pin_memory=self.pin_memory, shuffle=False)
print("task_ids", self.task_ids)
print(len(train_loader.dataset))
self.dataloaders[task_id]['train'] = train_loader
self.dataloaders[task_id]['valid'] = valid_loader
self.dataloaders[task_id]['test'] = test_loader
self.dataloaders[task_id]['name'] = 'Mydataset-{}-{}'.format(task_id, self.task_ids[task_id])
print("Training set size: {} images of {}x{}".format(len(train_loader.dataset), self.inputsize[1], self.inputsize[1]))
print("Validation set size: {} images of {}x{}".format(len(valid_loader.dataset), self.inputsize[1], self.inputsize[1]))
print("Test set size: {} images of {}x{}".format(len(test_loader.dataset), self.inputsize[1], self.inputsize[1]))
return self.dataloaders
