def transform_images(self, image_class_batch, batch_size, rotations,
current_class):
margin_image_batch = torch.Tensor(batch_size, 20, 20)
# Transforming image batch (EITHER HERE OR IN DATALOADER):
for b in range(batch_size):
img = Image.fromarray(image_class_batch[b].numpy())
if self.transform is not None:
# Applying class specific rotations:
if rotations[current_class][b] == 1:
img = transforms.vflip(img)
elif rotations[current_class][b] == 2:
img = transforms.hflip(img)
elif rotations[current_class][b] == 3:
img = transforms.hflip(transforms.vflip(img))
img = self.transform(img)
# Normalizing (pixels are binary):
threshold = torch.Tensor([0.0])
img = (img == threshold).float() * 1
# Adding to new tensor:
margin_image_batch[b] = img
return margin_image_batch
def __getitem__(self, index):
images = []
if self.train:
# Trains on whole dataset
img_classes = np.random.choice(len(self.train_labels), self.classes, replace=False)
# Trains on 3 classes:
#img_classes = np.random.choice(3, self.classes, replace=False)
ind = 0
for i in img_classes:
for j in self.train_data[i]:
images.append((j, ind))
ind += 1
else:
img_classes = np.random.choice(len(self.test_labels), self.classes, replace=False)
ind = 0
for i in img_classes:
for j in self.test_data[i]:
images.append((j, ind))
ind += 1
images_indexes = np.random.choice(len(images), self.batch_size, replace=False)
img_list = []
target_list = []
rotations = [0, 90, 180, 270]
image_rotations = [rotations[random.randint(0, len(rotations)-1)] for i in range(len(img_classes))]
for i in images_indexes:
img, label = images[i]
img = Image.fromarray(img.numpy())
if self.transform is not None:
# Applying class specific rotations:
if (image_rotations[label] == 90):
img = transforms.vflip(img)
elif (image_rotations[label] == 180):
img = transforms.hflip(img)
elif (image_rotations[label] == 180):
img = transforms.hflip(transforms.vflip(img))
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
# Normalizing (pixels are binary):
for row in range(len(img[0])):
for i in range(len(img[0][row])):
if (img[0][row][i] > 0):
img[0][row][i] = 0.0
else:
img[0][row][i] = 1.0
img_list.append(img)
target_list.append(label)
return img_list, target_list
def transform_image(self, image, rotation):
img = Image.fromarray(image.numpy())
if self.transform is not None:
# Applying class specific rotations:
if rotation == 1:
img = transforms.vflip(img)
elif rotation == 2:
img = transforms.hflip(img)
elif rotation == 3:
img = transforms.hflip(transforms.vflip(img))
img = self.transform(img)
# Normalizing (pixels are binary):
threshold = torch.Tensor([0.0])
img = (img == threshold).float() * 1
return img
def __getitem__(self, index):
if self.scenario:
images = []
if self.train:
img_classes = np.random.choice(len(self.train_labels),
2,
replace=False)
ind = 0
for i in img_classes:
if ind == 0:
for j in range(self.scenario_size):
images.append((self.train_data[i][j], ind))
else:
images.append(
(self.train_data[i][random.randint(0, 19)], ind))
ind += 1
else:
img_classes = np.random.choice(len(self.test_labels),
2,
replace=False)
ind = 0
for i in img_classes:
if ind == 0:
for j in range(self.scenario_size):
images.append((self.test_data[i][j], ind))
else:
images.append(
(self.test_data[i][random.randint(0, 19)], ind))
ind += 1
img_list, target_list = [], []
for i in range(len(images)):
img, label = images[i]
img = Image.fromarray(img.numpy())
if self.transform is not None:
img = self.transform(img)
# Normalizing (pixels are binary):
for row in range(len(img[0])):
for i in range(len(img[0][row])):
if img[0][row][i] > 0:
img[0][row][i] = 0.0
else:
img[0][row][i] = 1.0
img_list.append(img)
target_list.append(label)
return img_list, target_list
else:
images = []
if self.train:
# Train-dataset:
img_classes = np.random.choice(len(self.train_labels),
int(self.classes *
self.MARGIN_SIZE),
replace=False)
ind = 0
for i in img_classes:
relative_label = 0
for j in self.train_data[i]:
images.append((j, ind, relative_label))
relative_label += 1
ind += 1
else:
# Test-dataset:
img_classes = np.random.choice(len(self.test_labels),
int(self.classes *
self.MARGIN_SIZE),
replace=False)
ind = 0
for i in img_classes:
relative_label = 0
for j in self.test_data[i]:
images.append((j, ind, relative_label))
ind += 1
relative_label += 1
img_list = []
target_list = []
margins = {}
rotations = [0, 90, 180, 270]
margin_images = {}
image_rotations = [
rotations[random.randint(0,
len(rotations) - 1)]
for i in range(len(img_classes))
]
state = torch.FloatTensor([0 for i in range(self.classes)])
hidden = self.q_network.reset_hidden(1)
rand_label = random.randint(0, self.classes)
next_class = False
current_class = 0
# Calculating Margin:
for i in range(len(images)):
# So we dont have to transform ALL images (AKA also the ones were not gonna use):
if next_class == True and current_class == images[i][1]:
continue
else:
next_class = False
current_class = images[i][1]
img, label, rel_label = images[i]
img = Image.fromarray(img.numpy())
if self.transform is not None:
if self.train:
# Applying class specific rotations:
if image_rotations[label] == 90:
img = transforms.vflip(img)
elif image_rotations[label] == 180:
img = transforms.hflip(img)
elif image_rotations[label] == 270:
img = transforms.hflip(transforms.vflip(img))
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
# Normalizing (pixels are binary):
threshold = torch.Tensor([0.0])
img = (img == threshold).float() * 1
# Add transformed image to intermediary list:
if label not in margin_images:
margin_images[label] = [{rel_label: img}]
else:
margin_images[label].append({rel_label: img})
# Get class prediction value:
state = torch.cat((state, img.squeeze().view(-1)),
0).view(1, -1)
margin, hidden = self.q_network(Variable(state, volatile=True),
hidden)
state = torch.FloatTensor(
[1 if j == rand_label else 0 for j in range(self.classes)])
# First time new class:
if label not in margins:
margins[label] = [abs(margin.data.max(1)[0][0])]
# Margin-time > n > 1 sees a class:
elif len(margins[label]) < self.margin_time:
margins[label].append(abs(margin.data.max(1)[0][0]))
# n >= margin-time:
else:
state = torch.FloatTensor([0 for j in range(self.classes)])
hidden = self.q_network.reset_hidden(1)
rand_label = random.randint(0, self.classes)
next_class = True
largest = 0
smallest = 10000
for key in margins.keys():
margins[key] = sum(margins[key])
if margins[key] > largest:
largest = margins[key]
if margins[key] < smallest:
smallest = margins[key]
diff = largest - smallest
self.all_margins.append(diff)
sorted_margins = sorted(margins.items(),
key=operator.itemgetter(1))
if diff > self.big_diff:
print("Largest Margin Diff: ", diff)
self.big_diff = diff
margin_images_pruned, margin_labels = [], []
for x in range(self.classes):
margin_labels.append(sorted_margins[x][0])
margin_labels.sort()
img_list, target_list = [], []
imgs_to_transform = []
ind = 0
ind_dict = {}
for i in range(len(images)):
img, label, this_rel_label = images[i]
# Check if "valid" class:
if label in margin_labels:
dict_list = margin_images[label]
# Check if Image already been transformed:
if rel_label in dict_list:
if label not in ind_dict:
ind_dict[label] = ind
ind += 1
img_list.append(dict_list[rel_label])
target_list.append(ind_dict[label])
# If the image hasn'y been transformed yet:
else:
if label not in ind_dict:
ind_dict[label] = ind
ind += 1
imgs_to_transform.append((img, ind_dict[label], label))
else:
continue
images_indexes = np.random.choice(len(imgs_to_transform),
int(self.episode_size -
len(target_list)),
replace=False)
for i in images_indexes:
img, label, rot_label = imgs_to_transform[i]
img = Image.fromarray(img.numpy())
if self.transform is not None:
if self.train:
# Applying class specific rotations:
if image_rotations[rot_label] == 90:
img = transforms.vflip(img)
elif image_rotations[rot_label] == 180:
img = transforms.hflip(img)
elif image_rotations[rot_label] == 270:
img = transforms.hflip(transforms.vflip(img))
img = self.transform(img)
# Normalizing (pixels are binary):
threshold = torch.Tensor([0.0])
img = (img == threshold).float() * 1
img_list.append(img)
target_list.append(label)
return img_list, target_list
def __getitem__(self, index):
images = []
"""
label_list = ['a', 'b', 'c', 'd', 'e']
a = np.array(np.random.choice(len(label_list), len(label_list), replace=True))
b = np.zeros((len(label_list), len(label_list)))
b[np.arange(len(label_list)), a] = 1
"""
if self.train:
"""
# Trains on whole dataset
bits = np.array([np.array(np.random.choice(len(label_list), len(label_list), replace=True)) for c in range(self.classes)])
one_hot_vectors = np.array([np.zeros((len(label_list), len(label_list))) for c in range(self.classes)])
for c in range(self.classes):
one_hot_vectors[c][np.arange(len(label_list)), bits[c]] = 1
"""
img_classes = np.random.choice(len(self.train_labels),
self.classes,
replace=False)
ind = 0
for i in img_classes:
for j in self.train_data[i]:
images.append((j, ind))
ind += 1
else:
"""
# Trains on whole dataset
bits = np.array([np.array(np.random.choice(len(label_list), len(label_list), replace=True)) for c in range(self.classes)])
one_hot_vectors = np.array([np.zeros((len(label_list), len(label_list))) for c in range(self.classes)])
for c in range(self.classes):
one_hot_vectors[c][np.arange(len(label_list)), bits[c]] = 1
"""
img_classes = np.random.choice(len(self.test_labels),
self.classes,
replace=False)
ind = 0
for i in img_classes:
for j in self.test_data[i]:
images.append((j, ind))
ind += 1
images_indexes = np.random.choice(len(images),
self.episode_size,
replace=False)
img_list = []
target_list = []
rotations = [0, 90, 180, 270]
image_rotations = [
rotations[random.randint(0,
len(rotations) - 1)]
for i in range(len(img_classes))
]
for i in images_indexes:
img, label = images[i]
img = Image.fromarray(img.numpy())
if self.transform is not None:
# Applying class specific rotations:
if image_rotations[label] == 90:
img = transforms.vflip(img)
elif image_rotations[label] == 180:
img = transforms.hflip(img)
elif image_rotations[label] == 270:
img = transforms.hflip(transforms.vflip(img))
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
# Normalizing (pixels are binary):
for row in range(len(img[0])):
print(img[0][row])
input("Need norm?")
for i in range(len(img[0][row])):
if img[0][row][i] > 0:
img[0][row][i] = 0.0
else:
img[0][row][i] = 1.0
img_list.append(img)
target_list.append(label)
return img_list, target_list
def __getitem__(self, index):
if self.scenario:
images = []
# As in Active One-Shot Learning:
if self.scenario_type == 0:
if self.train:
img_classes = np.random.choice(len(self.train_labels), self.scenario_classes, replace=False)
ind = 0
for i in img_classes:
if ind == 0:
for j in range(self.scenario_size):
images.append((self.train_data[i][j], ind))
else:
images.append((self.train_data[i][random.randint(0, len(self.train_data[i]) - 1)], ind))
ind += 1
else:
img_classes = np.random.choice(len(self.test_labels), self.scenario_classes, replace=False)
ind = 0
for i in img_classes:
if ind == 0:
for j in range(self.scenario_size):
images.append((self.test_data[i][j], ind))
else:
images.append((self.test_data[i][random.randint(0, len(self.test_data[i]) - 1)], ind))
ind += 1
# My own:
elif self.scenario_type == 1:
if self.train:
img_classes = np.random.choice(len(self.train_labels), self.scenario_classes, replace=False)
ind = 0
for i in img_classes:
if ind == self.class_choice:
img_samples = np.random.choice(len(self.train_data[i]), self.scenario_size, replace=False)
for j in img_samples:
images.append((self.train_data[i][j], ind))
else:
images.append((self.train_data[i][random.randint(0, len(self.train_data[i]) - 1)], ind))
ind += 1
else:
img_classes = np.random.choice(len(self.test_labels), self.scenario_classes, replace=False)
ind = 0
for i in img_classes:
if ind == self.class_choice:
img_samples = np.random.choice(len(self.test_data[i]), self.scenario_size, replace=False)
for j in img_samples:
images.append((self.test_data[i][j], ind))
else:
images.append((self.test_data[i][random.randint(0, len(self.test_data[i]) - 1)], ind))
ind += 1
elif self.scenario_type == 2:
if self.train:
img_classes = np.random.choice(len(self.train_labels), self.scenario_classes, replace=False)
ind = 0
for i in img_classes:
img_samples = np.random.choice(len(self.train_data[i]), self.scenario_size, replace=False)
for j in img_samples:
images.append((self.train_data[i][j], ind))
ind += 1
else:
img_classes = np.random.choice(len(self.test_labels), self.scenario_classes, replace=False)
ind = 0
for i in img_classes:
img_samples = np.random.choice(len(self.test_data[i]), self.scenario_size, replace=False)
for j in img_samples:
images.append((self.test_data[i][j], ind))
ind += 1
elif self.scenario_type == 3:
if self.train:
img_classes = np.random.choice(len(self.train_labels), self.scenario_classes, replace=False)
appended_images = []
ind = 0
k = 0
for i in img_classes:
if ind == self.class_choice:
img_samples = np.random.choice(len(self.train_data[i]), self.scenario_size, replace=False)
else:
img_samples = np.random.choice(len(self.train_data[i]), 1, replace=False)
for j in img_samples:
if ind == self.class_choice:
if k == 0:
images.append((self.train_data[i][j], ind))
else:
appended_images.append((self.train_data[i][j], ind))
else:
images.append((self.train_data[i][j], ind))
k += 1
ind += 1
for img in appended_images:
images.append(img)
else:
img_classes = np.random.choice(len(self.test_labels), self.scenario_classes, replace=False)
appended_images = []
ind = 0
k = 0
for i in img_classes:
if ind == self.class_choice:
img_samples = np.random.choice(len(self.test_data[i]), self.scenario_size, replace=False)
else:
img_samples = np.random.choice(len(self.test_data[i]), 1, replace=False)
for j in img_samples:
if ind == self.class_choice:
if k == 0:
images.append((self.test_data[i][j], ind))
else:
appended_images.append((self.test_data[i][j], ind))
else:
images.append((self.test_data[i][j], ind))
k += 1
ind += 1
for img in appended_images:
images.append(img)
img_list, target_list = [], []
for i in range(len(images)):
img, label = images[i]
img = Image.fromarray(img.numpy())
if self.transform is not None:
img = self.transform(img)
# Normalizing (pixels are binary):
threshold = torch.Tensor([0.0])
img = (img == threshold).float() * 1
img_list.append(img)
target_list.append(label)
return img_list, target_list
else:
images = []
if self.train:
# Trains on whole dataset
img_classes = []
while len(img_classes) < self.classes:
r = random.randint(0, len(self.train_labels) - 1)
if r not in img_classes:
img_classes.append(r)
ind = 0
for i in img_classes:
for j in self.train_data[i]:
images.append((j, ind))
ind += 1
else:
img_classes = np.random.choice(len(self.test_labels), self.classes, replace=False)
ind = 0
for i in img_classes:
for j in self.test_data[i]:
images.append((j, ind))
ind += 1
images_indexes = []
indexes = np.arange(len(images))
while len(images_indexes) < self.episode_size:
r = indexes[random.randint(0, len(indexes) - 1)]
images_indexes.append(r)
np.delete(indexes, r)
img_list = []
target_list = []
rotations = [0, 90, 180, 270]
image_rotations = [rotations[random.randint(0, len(rotations)-1)] for i in range(len(img_classes))]
for i in images_indexes:
img, label = images[i]
img = Image.fromarray(img.numpy())
if self.transform is not None:
if self.train and not self.test:
# Applying class specific rotations:
if image_rotations[label] == 90:
img = transforms.vflip(img)
elif image_rotations[label] == 180:
img = transforms.hflip(img)
elif image_rotations[label] == 270:
img = transforms.hflip(transforms.vflip(img))
img = self.transform(img)
if self.target_transform is not None:
target = self.target_transform(target)
# Normalizing (pixels are binary):
threshold = torch.Tensor([0.0])
img = (img == threshold).float() * 1
img_list.append(img)
target_list.append(label)
return img_list, target_list