def plot_grid(images, tsne, tx, ty):
nx = int(math.ceil(math.sqrt(len(images))))
ny = nx
grid_assignment = rasterfairy.transformPointCloud2D(tsne, target=(nx, ny))
tile_width = 144
tile_height = 112
full_width = tile_width * nx
full_height = tile_height * ny
aspect_ratio = float(tile_width) / tile_height
grid_image = PIL.Image.new('RGB', (full_width, full_height))
for img, grid_pos in tqdm.tqdm(zip(images, grid_assignment[0].tolist())):
idx_x, idx_y = grid_pos
x, y = tile_width * idx_x, tile_height * idx_y
tile = imageutils.load_image(img)
tile_ar = float(
tile.width
) / tile.height # center-crop the tile to match aspect_ratio
if (tile_ar > aspect_ratio):
margin = 0.5 * (tile.width - aspect_ratio * tile.height)
tile = tile.crop(
(margin, 0, margin + aspect_ratio * tile.height, tile.height))
else:
margin = 0.5 * (tile.height - float(tile.width) / aspect_ratio)
tile = tile.crop((0, margin, tile.width,
margin + float(tile.width) / aspect_ratio))
tile = tile.resize((tile_width, tile_height), PIL.Image.ANTIALIAS)
grid_image.paste(tile, (int(x), int(y)))
return grid_image
def image_grid2(images, Z, ny=25, nx=40, out_name="grid2.png"):
import rasterfairy
from PIL import Image
# assign to grid
grid_assignment = rasterfairy.transformPointCloud2D(Z, target=(nx, ny))
print(grid_assignment)
tile_width = 32
tile_height = 32
full_width = tile_width * nx
full_height = tile_height * ny
# aspect_ratio = float(tile_width) / tile_height
grid_image = Image.new("RGB", (full_width, full_height))
for img, grid_pos in zip(images, grid_assignment[0]):
idx_x, idx_y = grid_pos
x, y = tile_width * idx_x, tile_height * idx_y
print(idx_x, idx_y, x, y)
tile = Image.fromarray(img.reshape((32, 32, 3)).astype("uint8"), "RGB")
grid_image.paste(tile, box=(int(x), int(y), int(x) + 32, int(y) + 32))
grid_image.save(out_name)
def generate_mosaic(embeddings,
images,
mosaic_width,
mosaic_height,
tile_width=72,
tile_height=56,
title="Doppler Mosaic",
title_rbg=(229, 229, 229),
save_as_file=False,
return_image=True,
verbose=False):
'''
Transforms 2-dimensional embeddings to a grid.
Plots the images for each embedding in the corresponding grid (mosaic).
Includes arguments for the dimensions of each tile and the the mosaic.
'''
# assign to grid
grid_assignment = transformPointCloud2D(embeddings,
target=(mosaic_width,
mosaic_height))
full_width = tile_width * mosaic_width
full_height = tile_height * (mosaic_height + 2)
aspect_ratio = float(tile_width) / tile_height
# create an empty image for the mosaic
mosaic = Image.new('RGB', (full_width, full_height))
# iterate through each image and where it is possed to live.
for f_img, (idx_x, idx_y) in tqdm(zip(images, grid_assignment[0]),
disable=not verbose):
# Find exactly where the image will be
x, y = tile_width * idx_x, tile_height * idx_y
# read the image, center crop the image and add it to the mosaic
try:
img = Image.open(f_img).convert('RGBA')
tile = resize_image(img, tile_width, tile_height, aspect_ratio)
mosaic.paste(tile, (int(x), int(y)))
except Exception as e:
print(f"Failed to add image {f_img} see error:\n{e}")
# write an annotation
fnt = ImageFont.truetype('Pillow/Tests/fonts/FreeMono.ttf',
int(tile_height * 1.2))
draw = ImageDraw.Draw(mosaic)
draw.text((4, (tile_height * (mosaic_height)) + 10),
title,
title_rbg,
font=fnt)
if save_as_file and not os.path.exists(save_as_file):
try:
mosaic.save(save_as_file)
except Exception as e:
print(
f'Saving the mosaic to {save_as_file} failed, see error:\n{e}')
if return_image:
return mosaic
def tsne_to_grid(data, output):
# https://github.com/Quasimondo/RasterFairy/blob/master/examples/Raster%20Fairy%20Demo%201.ipynb
# https://github.com/bmcfee/RasterFairy (vpython3)
# from sklearn.decomposition import PCA
import rasterfairy
import math
data = np.array(data)
# pca = PCA(n_components=500, whiten=True)
n_pts = data.shape[0]
# data_pca = pca.fit_transform(data)
data_pca, U, V = pca(data, pc_count=500)
data_pca = list(data_pca)
sqrt_npts = math.ceil(math.sqrt(n_pts))
n_diff = sqrt_npts**2 - n_pts
data_pca += [data_pca[-1]] * n_diff
data_pca = np.array(data_pca)
list_file += [list_file[-1]] * n_diff
tsne = TSNE_multi(n_components=2, perplexity=50, n_jobs=8)
data_tsne = tsne.fit_transform(data_pca.astype(np.float64))
arrangements = rasterfairy.getRectArrangements(data_tsne.shape[0])
img = cv2.imread(list_file[0])
ratio = img.shape[0] / img.shape[1]
r = 0.1
dim = (int(img.shape[1] * r), int(img.shape[0] * r))
img = cv2.resize(img, dim, interpolation=cv2.INTER_AREA)
dim_x = img.shape[0]
dim_y = img.shape[1]
grid_xy, (width, height) = rasterfairy.transformPointCloud2D(
data_tsne, target=arrangements[0])
img_big = np.zeros((dim_x * width, dim_y * height, 3))
for i, file_img in enumerate(list_file):
xy = grid_xy[i, :]
pos_x = int(xy[0] * dim_x)
pos_y = int(xy[1] * dim_y)
img = cv2.imread(file_img)
r = 0.1
dim = (int(img.shape[1] * r), int(img.shape[0] * r))
img = cv2.resize(img, dim, interpolation=cv2.INTER_AREA)
img_big[pos_x:pos_x + dim_x, pos_y:pos_y + dim_y, :] = img
cv2.imwrite(output, img_big)
def get_rasterfairy_projection(**kwargs):
'''Get the x, y position of images passed through a rasterfairy projection'''
print(' * creating rasterfairy layout')
out_path = get_path('layouts', 'rasterfairy', **kwargs)
if os.path.exists(out_path) and kwargs['use_cache']: return out_path
umap = np.array(read_json(kwargs['umap'], **kwargs))
umap = (umap + 1) / 2 # scale 0:1
umap = coonswarp.rectifyCloud(
umap, # stretch the distribution
perimeterSubdivisionSteps=4,
autoPerimeterOffset=False,
paddingScale=1.05)
pos = rasterfairy.transformPointCloud2D(umap)[0]
return write_layout(out_path, pos, **kwargs)
def generate_mosaic(embeddings, images, titles, origins, urls, mosaic_width=1000, mosaic_height=1000, tile_width=150, tile_height=100,
title_rbg=(255, 255, 255), save_as_file='mosaic.png',
fb_counts=None,partisanship=None,verbose=True,
return_image=True, title="Doppler Mosaic" ):
"""
Transforms 2-dimensional embeddings to a grid.
Plots the images for each embedding in the corresponding grid (mosaic).
Includes arguments for the dimensions of each tile and the the mosaic.
"""
# assign to grid
grid_assignment = transformPointCloud2D(embeddings,
target=(mosaic_width,
mosaic_height))
full_width = tile_width * mosaic_width
full_height = tile_height * (mosaic_height + 2)
aspect_ratio = float(tile_width) / tile_height
#print(grid_assignment)
# create an empty image for the mosaic
mosaic = Image.new('RGB', (full_width, full_height))
# iterate through each image and where it is possed to live.
for f_img, (idx_x, idx_y) in tqdm(zip(images, grid_assignment[0]),
disable = False):
# Find exactly where the image will be
x, y = tile_width * idx_x, tile_height * idx_y
# read the image, center crop the image and add it to the mosaic
try:
img = Image.open(f_img).convert('RGBA')
tile = resize_image(img, tile_width, tile_height, aspect_ratio)
mosaic.paste(tile, (int(x), int(y)))
except Exception as e:
print(f"Failed to add image {f_img} see error:\n{e}")
draw = ImageDraw.Draw(mosaic)
#draw.text((4, (tile_height * (mosaic_height)) + 10),title, title_rbg, font=fnt)
if save_as_file and not os.path.exists(save_as_file):
try:
mosaic.save(save_as_file)
except Exception as e:
print(f'Saving the mosaic to {save_as_file} failed, see error:\n{e}')
if return_image:
return mosaic
def make_collage(self) -> np.array:
"""
Make collage based on activation space visual similarity.
This method:
1. computes t-SNE embeddings
2. computes the square grid based on embeddings
3. creates the collage array and fills it with images from dataset
:return: 3-channel array representing square collage image
"""
collage_activations: Tensor = self.data_activations[:self.
collage_data_size]
# edge case: only 1 image uploaded -> return the image itself
if len(collage_activations) == 1:
return self._get_array_from_image(self.data.train_ds[0][0])
# prepare the grid
tsne: np.array = TSNE().fit_transform(collage_activations)
grid_arrangement: Tuple[int, int] = (self.collage_grid_size,
self.collage_grid_size)
grid_xy, _ = rasterfairy.transformPointCloud2D(tsne,
target=grid_arrangement)
# create the collage
collage_size = self.collage_grid_size * self.data.img_size
collage = np.zeros([collage_size, collage_size, 3]) # empty collage
for i in range(self.collage_data_size):
row, col = map(
int, grid_xy[i]) # grid has floats, but need ints to index
up = row * self.data.img_size
down = (row + 1) * self.data.img_size
left = col * self.data.img_size
right = (col + 1) * self.data.img_size
collage[up:down, left:right] = self._get_array_from_image(
self.data.train_ds[i][0])
return collage
# full_image.paste(tile, (int((width-max_dim)*x), int((height-max_dim)*y)), mask=tile.convert('RGBA'))
# matplotlib.pyplot.figure(figsize = (16,12))
# imshow(full_image)
# -----------------------
# Grid-wise visualization
# -----------------------
# Note that nx * ny = len(images)
nx = int(np.sqrt(len(images)))
ny = int(np.sqrt(len(images)))
# assign to grid
grid_assignment = rasterfairy.transformPointCloud2D(tsne, target=(nx, ny))
tile_width = 100
tile_height = 100
full_width = tile_width * nx
full_height = tile_height * ny
aspect_ratio = float(tile_width) / tile_height
grid_image = Image.new('RGB', (full_width, full_height))
for img, grid_pos in zip(images, grid_assignment[0]):
idx_x, idx_y = grid_pos
x, y = tile_width * idx_x, tile_height * idx_y
tile = Image.open(img)
def main():
images, pca_features = pickle.load(
open(os.path.join(save_dir, 'features.p'), 'r'))
for i, f in list(zip(images, pca_features))[0:5]:
print(i, f[0], f[1], f[2])
if len(images) > num_images_to_plot:
sort_order = sorted(
random.sample(range(len(images)), num_images_to_plot))
images = [images[i] for i in sort_order]
pca_features = [pca_features[i] for i in sort_order]
X = np.array(pca_features)
tsne = TSNE(n_components=2,
learning_rate=150,
perplexity=30,
angle=0.2,
verbose=2).fit_transform(X)
tx, ty = tsne[:, 0], tsne[:, 1]
tx = (tx - np.min(tx)) / (np.max(tx) - np.min(tx))
ty = (ty - np.min(ty)) / (np.max(ty) - np.min(ty))
#random.shuffle(tx)
#random.shuffle(ty)
T = np.arctan2(ty, tx)
print(type(T))
print(len(T))
#plt.scatter(tx,ty,s=55, c=T, alpha=.3)
#plt.savefig(os.path.join(save_dir, 'image', 'scatter.png'))
width = 4000
height = 3000
max_dim = 120
full_list = []
for gif_file in images:
sample_list = _sample_image(gif_file)
full_list.append(sample_list)
full_list = np.array(full_list)
for i in range(_STRIDE):
image_list = full_list[:, i]
full_image = Image.new('RGBA', (width, height))
for img, x, y in tqdm(zip(image_list, tx, ty)):
tile = Image.open(img)
rs = max(1, tile.width / max_dim, tile.height / max_dim)
tile = tile.resize((int(tile.width / rs), int(tile.height / rs)),
Image.ANTIALIAS)
full_image.paste(tile, (int((width - max_dim) * x), 3000 - int(
(height - max_dim) * y)),
mask=tile.convert('RGBA'))
#plt.figure(figsize = (16,12))
#imshow(full_image)
full_image.save(os.path.join(save_dir, 'image', str(i) + '.png'))
#plt.show()
tsne_path = os.path.join(save_dir, 'grid.json')
data = [{
"path": os.path.abspath(img),
"point": [float(x), float(y)]
} for img, x, y in zip(images, tx, ty)]
with open(tsne_path, 'w') as outfile:
json.dump(data, outfile)
print "saved t-SNE result to %s" % tsne_path
exit(1)
arrangements = rasterfairy.getRectArrangements(num_images_to_plot)
nx = arrangements[0][1]
ny = arrangements[0][0]
grid_assignment = rasterfairy.transformPointCloud2D(tsne, target=(nx, ny))
print 'finished', arrangements
tile_width = 72
tile_height = 56
full_width = tile_width * nx
full_height = tile_height * ny
aspect_ratio = float(tile_width) / tile_height
grid_image = Image.new('RGB', (full_width, full_height))
grid_list = grid_assignment[0]
for i in range(_STRIDE):
image_list = full_list[:, i]
for img, grid_pos in tqdm(zip(image_list, grid_list)):
idx_x, idx_y = grid_pos
x, y = tile_width * idx_x, tile_height * idx_y
tile = Image.open(img)
tile_ar = float(
tile.width
) / tile.height # center-crop the tile to match aspect_ratio
if (tile_ar > aspect_ratio):
margin = 0.5 * (tile.width - aspect_ratio * tile.height)
tile = tile.crop(
(margin, 0, margin + aspect_ratio * tile.height,
tile.height))
else:
margin = 0.5 * (tile.height - float(tile.width) / aspect_ratio)
tile = tile.crop((0, margin, tile.width,
margin + float(tile.width) / aspect_ratio))
tile = tile.resize((tile_width, tile_height), Image.ANTIALIAS)
grid_image.paste(tile, (int(x), int(y)))
plt.figure(figsize=(16, 12))
grid_image.save(os.path.join(save_dir, 'image', str(i) + '_grid.png'))
for i, line in enumerate(f):
if i == 0 and skip_header:
header = line
continue
data = line.split(',')
syllable = data[0]
x = float(data[1])
y = float(data[2])
labels.append(syllable)
points.append([x, y])
print('- found ' + str(len(labels)) + ' unique words')
# convert to tsne object and grid it
print('reformatting into a grid...')
xy = TSNE().fit_transform(points)
arrangements = rasterfairy.getRectArrangements(len(labels))
grid_xy, (width, height) = rasterfairy.transformPointCloud2D(xy)
print('- grid dimensions: ' + str(width) + ' x ' + str(height))
print('- done')
# write out grid data to file
print('saving to file...')
data = zip(labels, grid_xy)
with open(output_filename, 'w') as f:
if header is not None: # put back csv header, if there was one
f.write(header)
for label, point in data:
f.write(label + ',' + str(int(point[0])) + ',' + str(int(point[1])) +
'\n')
print('- done!')
PATH = "/Users/Muriz/Desktop/05vis.png"
Image(filename=PATH, width='100%', height=140)
# In[ ]:
get_ipython().system('git clone https://github.com/Quasimondo/RasterFairy.git')
# In[ ]:
get_ipython().system(' pip install ./RasterFairy/.')
# In[ ]:
import rasterfairy
grid_assignment = rasterfairy.transformPointCloud2D(tsne)
# In[ ]:
tile_width = 48
tile_height = 50
full_width = tile_width * 125
full_height = tile_height * 160
aspect_ratio = float(tile_width) / tile_height
grid_image = Image.new('RGB', (full_width, full_height))
for img, grid_pos in tqdm(zip(images, grid_assignment[0])):
idx_x, idx_y = grid_pos
x, y = tile_width * idx_x, tile_height * idx_y
def main():
"""Perform t-SNE."""
# read parameters for wanted dataset from config file
with open('config.json') as json_file:
config_json = json.load(json_file)
config = config_json[args['dataset']]
# create directories to save results if they don't exist yet
resultspath = os.path.join(os.path.dirname(os.getcwd()), 'results')
if not os.path.exists(resultspath):
os.makedirs(resultspath)
# set a random seed
seed = 28
# if features are not yet extracted, extract them
if not os.path.exists(
os.path.join(config['output_path'], 'pca_features_50.p')):
# load the pre-trained source network
print("loading network...")
dataset = args['dataset']
modelpath = os.path.join(config['model_savepath'],
'{}_model.h5'.format(dataset))
model = load_model(modelpath)
model.summary()
# create network instance
network = NeuralNetwork(model, config, batchsize=1, seed=seed)
# set create a bottleneck model at specified layer
network.set_bottleneck_model(outputlayer='flatten_1')
network.model.summary()
# extract features using bottleneck model
print("extracting features...")
bn_features_train, bn_features_test, true_labels_train, true_labels_test = network.extract_bottleneck_features(
)
# scale the data to zero mean, unit variance for PCA
scaler = StandardScaler()
train_features = scaler.fit_transform(bn_features_train)
# fit PCA
print("applying PCA...")
# pca = PCA(.90)
pca = PCA(n_components=50)
# print('Cumulative explained variation for 50 principal components: {}'.format(np.sum(pca.explained_variance_ratio_)))
pca.fit(train_features)
# apply PCA to features and test data
reduced_train_features = pca.transform(train_features)
# create list of full file paths
train_paths = [
os.path.join(config['trainingpath'], filename)
for filename in network.gen_training.filenames
]
# convert to arrays
pca_features = np.array(reduced_train_features)
images = np.array(train_paths)
# save extracted features in a pickle file
print("saving features...")
pickle.dump([images, pca_features, pca],
open(
os.path.join(config['output_path'],
'pca_features_50.p'), 'wb'))
else:
# load features if they are already once extracted
print("loading features...")
images, pca_features, pca = pickle.load(
open(os.path.join(config['output_path'], 'pca_features_50.p'),
'rb'))
for img, f in list(zip(images, pca_features))[0:5]:
print("image: %s, features: %0.2f,%0.2f,%0.2f,%0.2f... " %
(img, f[0], f[1], f[2], f[3]))
# only plot the input amount of images, if no input is given or input is larger than number of images, use all images
if args['num_images'] == 0 or args['num_images'] > len(images):
num_images_to_plot = len(images)
else:
num_images_to_plot = args['num_images']
print("number of images used for t-SNE: {}".format(num_images_to_plot))
# set random seed to always get the same random samples
random.seed(seed)
if len(images) > num_images_to_plot:
sort_order = sorted(
random.sample(range(len(images)), num_images_to_plot))
images = [images[i] for i in sort_order]
pca_features = [pca_features[i] for i in sort_order]
# # only take the number of images to plot
# images = images[:num_images_to_plot]
# pca_features = pca_features[:num_images_to_plot]
print("performing t-SNE...")
if args['dims'] == '2D':
perplexity = int(np.sqrt(num_images_to_plot))
tsne = TSNE(n_components=2,
learning_rate=150,
perplexity=perplexity,
random_state=seed,
angle=0.2,
verbose=2).fit_transform(np.array(pca_features))
if args['dims'] == '3D':
perplexity = int(np.sqrt(num_images_to_plot))
tsne = TSNE(n_components=3,
learning_rate=150,
perplexity=perplexity,
random_state=seed,
angle=0.2,
verbose=2).fit_transform(np.array(pca_features))
if args['mode'] == 'images':
print("creating t-SNE image...")
# normalize the embedding
tx, ty = tsne[:, 0], tsne[:, 1]
tx = (tx - np.min(tx)) / (np.max(tx) - np.min(tx))
ty = (ty - np.min(ty)) / (np.max(ty) - np.min(ty))
width = 4000
height = 3000
max_dim = 100
full_image = Image.new('RGBA', (width, height))
for img, x, y in zip(images, tx, ty):
tile = Image.open(img)
if 'ISIC' in args['dataset']:
if 'malignant' in img:
old_size = tile.size
new_size = (old_size[0] + 20, old_size[1] + 20)
new_im = Image.new("RGB", new_size, "red")
new_im.paste(tile, (int((new_size[0] - old_size[0]) / 2),
int((new_size[1] - old_size[1]) / 2)))
tile = new_im
if 'benign' in img:
old_size = tile.size
new_size = (old_size[0] + 20, old_size[1] + 20)
new_im = Image.new("RGB", new_size, "green")
new_im.paste(tile, (int((new_size[0] - old_size[0]) / 2),
int((new_size[1] - old_size[1]) / 2)))
tile = new_im
if 'CNMC' in args['dataset']:
if 'leukemic' in img:
old_size = tile.size
new_size = (old_size[0] + 20, old_size[1] + 20)
new_im = Image.new("RGB", new_size, "red")
new_im.paste(tile, (int((new_size[0] - old_size[0]) / 2),
int((new_size[1] - old_size[1]) / 2)))
tile = new_im
if 'normal' in img:
old_size = tile.size
new_size = (old_size[0] + 20, old_size[1] + 20)
new_im = Image.new("RGB", new_size, "green")
new_im.paste(tile, (int((new_size[0] - old_size[0]) / 2),
int((new_size[1] - old_size[1]) / 2)))
tile = new_im
rs = max(1, tile.width / max_dim, tile.height / max_dim)
tile = tile.resize((int(tile.width / rs), int(tile.height / rs)),
Image.ANTIALIAS)
full_image.paste(tile, (int(
(width - max_dim) * x), int((height - max_dim) * y)),
mask=tile.convert('RGBA'))
plt.figure(figsize=(16, 12))
plt.imshow(full_image)
full_image.save(
os.path.join(
config['output_path'],
'tSNE-images-{}-{}-2D-pca_50.png'.format(
args['dataset'], num_images_to_plot)))
print("creating t-SNE grid image...")
# get dimensions for the raster that is closest to a square, where all the images fit
max_side = int(num_images_to_plot**(1 / 2.0))
for ny in range(2, max_side + 1)[::-1]:
nx = num_images_to_plot // ny
if (ny * nx) == num_images_to_plot:
break
# assign to grid
grid_assignment = rasterfairy.transformPointCloud2D(tsne,
target=(nx, ny))
tile_width = 70
tile_height = 70
full_width = tile_width * nx
full_height = tile_height * ny
aspect_ratio = float(tile_width) / tile_height
grid_image = Image.new('RGB', (full_width, full_height))
for img, grid_pos in zip(images, grid_assignment[0]):
idx_x, idx_y = grid_pos
x, y = tile_width * idx_x, tile_height * idx_y
# tile = Image.open(img)
tile = Image.open(img)
if 'ISIC' in args['dataset']:
if 'malignant' in img:
old_size = tile.size
new_size = (old_size[0] + 20, old_size[1] + 20)
new_im = Image.new("RGB", new_size, "red")
new_im.paste(tile, (int((new_size[0] - old_size[0]) / 2),
int((new_size[1] - old_size[1]) / 2)))
tile = new_im
if 'benign' in img:
old_size = tile.size
new_size = (old_size[0] + 20, old_size[1] + 20)
new_im = Image.new("RGB", new_size, "green")
new_im.paste(tile, (int((new_size[0] - old_size[0]) / 2),
int((new_size[1] - old_size[1]) / 2)))
tile = new_im
if 'CNMC' in args['dataset']:
if 'leukemic' in img:
old_size = tile.size
new_size = (old_size[0] + 20, old_size[1] + 20)
new_im = Image.new("RGB", new_size, "red")
new_im.paste(tile, (int((new_size[0] - old_size[0]) / 2),
int((new_size[1] - old_size[1]) / 2)))
tile = new_im
if 'normal' in img:
old_size = tile.size
new_size = (old_size[0] + 20, old_size[1] + 20)
new_im = Image.new("RGB", new_size, "green")
new_im.paste(tile, (int((new_size[0] - old_size[0]) / 2),
int((new_size[1] - old_size[1]) / 2)))
tile = new_im
tile_ar = float(
tile.width
) / tile.height # center-crop the tile to match aspect_ratio
if (tile_ar > aspect_ratio):
margin = 0.5 * (tile.width - aspect_ratio * tile.height)
tile = tile.crop(
(margin, 0, margin + aspect_ratio * tile.height,
tile.height))
else:
margin = 0.5 * (tile.height - float(tile.width) / aspect_ratio)
tile = tile.crop((0, margin, tile.width,
margin + float(tile.width) / aspect_ratio))
tile = tile.resize((tile_width, tile_height), Image.ANTIALIAS)
grid_image.paste(tile, (int(x), int(y)))
plt.figure(figsize=(16, 12))
plt.imshow(grid_image)
grid_image.save(
os.path.join(
config['output_path'],
'tSNE-grid-{}-{}-pca_50.png'.format(args['dataset'],
num_images_to_plot)))
# for plotting points
if args['mode'] == 'points':
if args['dims'] == '2D':
print("creating t-SNE image...")
plt.figure(figsize=(16, 10))
tx, ty = tsne[:, 0], tsne[:, 1]
y = []
# create labels for color coding
for img in images:
if 'ISIC' in args['dataset']:
if 'malignant' in img:
y.append(0)
if 'benign' in img:
y.append(1)
if 'CNMC' in args['dataset']:
if 'leukemic' in img:
y.append(0)
if 'normal' in img:
y.append(1)
# set red and green color palette for the classes
palette = sns.color_palette(['#00FF00', '#FF0000'])
# plot the data
sns.scatterplot(tx, ty, hue=y, legend='full', palette=palette)
# set legend
if 'ISIC' in args['dataset']:
plt.legend(labels=['malignant', 'benign'], loc="upper right")
if 'CNMC' in args['dataset']:
plt.legend(labels=['leukemic', 'normal'], loc="upper right")
# save the t-SNE plot
plt.savefig(
os.path.join(
config['output_path'],
'tSNE-points-{}-{}-2D-pca_50.png'.format(
args['dataset'], num_images_to_plot)))
if args['dims'] == '3D':
print("creating t-SNE image...")
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
tx, ty, tz = tsne[:, 0], tsne[:, 1], tsne[:, 2]
y = []
# create labels for color coding
for img in images:
if 'ISIC' in args['dataset']:
if 'malignant' in img:
y.append(0)
if 'benign' in img:
y.append(1)
if 'CNMC' in args['dataset']:
if 'leukemic' in img:
y.append(0)
if 'normal' in img:
y.append(1)
ax.scatter(tx, ty, tz, c=y, cmap="RdYlGn_r", alpha=1.0)
# set legend
if 'ISIC' in args['dataset']:
plt.legend(labels=['benign', 'malignant'], loc="upper right")
if 'CNMC' in args['dataset']:
plt.legend(labels=['normal', 'leukemic'], loc="upper right")
# save the t-SNE plot
plt.savefig(
os.path.join(
config['output_path'],
'tSNE-points-{}-{}-3D-pca_50.png'.format(
args['dataset'], num_images_to_plot)))
num_datapoints = len(filenames)
print '- loaded data for ' + str(num_datapoints) + ' images'
# calculate arrangement
print 'calculating arrangements...'
arrangements = rasterfairy.getRectArrangements(num_datapoints)
print '- best candidate: ' + str(arrangements[0])
if force_layout:
print '- ignoring and using (' + str(grid_width) + 'x' + str(grid_height) + ') instead'
# convert to a grid, save results to a CSV file for later use
print 'laying out grid...'
if force_layout:
grid, (width, height) = rasterfairy.transformPointCloud2D(X, target=(grid_width, grid_height))
else:
grid, (width, height) = rasterfairy.transformPointCloud2D(X, target=arrangements[0])
data = zip(filenames, grid)
with open(output_filename, 'w') as f:
f.write('path,x,y' + '\n')
for path, pos in data:
f.write(path + ',' + str(int(pos[0])) + ',' + str(int(pos[1])) + '\n')
print '- done (laid out to ' + str(width) + 'x' + str(height) + ' grid)'
# try optimizing the grid layout, though may choke on large data # print 'optimizing (' + str(num_iterations) + ' iterations)'
# optimizer = rfoptimizer.SwapOptimizer()
# swap_table = optimizer.optimize(X, grid, grid_width, grid_height, num_iterations)
def run_rasterfairy(projections):
side_len = math.ceil(math.sqrt(len(projections)))
return rasterfairy.transformPointCloud2D(projections,
target=(side_len, side_len))
def run(start_x, end_x, start_y, end_y):
print '(' + str(start_x) + ', ' + str(start_y) + ')'
# load up all 2D points and filenames
print 'loading data from file...'
filenames = []
X = []
with open(input_filename) as f:
f.next() # skip header
for i, line in enumerate(f):
line = line.strip().split(',')
x = float(line[1])
y = float(line[2])
if x >= start_x and x <=end_x and y >= start_y and y <= end_y:
X.append( [ x, y ] )
filenames.append(line[0])
X = np.array(X)
num_datapoints = X.shape[0]
print '- loaded data for ' + str(num_datapoints) + ' images'
# calculate arrangement
print 'calculating arrangements...'
arrangements = rasterfairy.getRectArrangements(num_datapoints)
print '- best candidate: ' + str(arrangements[0])
# convert to a grid
print 'laying out grid...'
# grid, (width, height) = rasterfairy.transformPointCloud2D(X, target=(grid_width,grid_height))
grid, (width, height) = rasterfairy.transformPointCloud2D(X, target=arrangements[0])
print '- done (laid out to ' + str(width) + 'x' + str(height) + ' grid)'
# try optimizing the grid layout, though may choke on large data
print 'optimizing (' + str(num_iterations) + ' iterations)'
optimizer = SwapOptimizer()
swap_table, improvement = optimizer.optimize(X, grid, width, height, num_iterations, verbose=False)
print '- improvement of ' + str(improvement)
if improvement > 0:
print 'still room for more optimization, running again...'
iterations = 0
num_improvement_iterations = 5
while True:
if improvement <= 0:
print ' - no more improvement, stopping...'
break
elif iterations == num_improvement_iterations:
print ' - reached max number of iterations, stopping...'
break
print '- continuing ' + str(num_iterations) + ' iterations of optimization...'
swap_table, improvement = optimizer.continueOptimization(iterations*num_iterations, shakeIterations=shake_iterations, verbose=False)
iterations += 1
print ' - improvement of ' + str(improvement)
print '- done'
# save results to a csv file for later use
print 'saving to file...'
data = zip(filenames, grid[swap_table])
with open(output_filename, 'w') as f:
f.write('path,x,y' + '\n')
for path, pos in data:
f.write(path + ',' + str(int(pos[0])) + ',' + str(int(pos[1])) + '\n')
print '- done'
import rasterfairy
import sys
from lib.utils import *
# input
parser = argparse.ArgumentParser()
parser.add_argument('-in',
dest="INPUT_FILE",
default="data/photographic_tsne.csv",
help="Input csv file")
parser.add_argument('-out',
dest="OUTPUT_FILE",
default="data/photographic_grid.csv",
help="Output csv file")
a = parser.parse_args()
model = np.loadtxt(a.INPUT_FILE, delimiter=",")
count = len(model)
print("Determining grid assignment...")
gridAssignment = rasterfairy.transformPointCloud2D(model)
grid, gridShape = gridAssignment
print("Resulting shape:")
print(gridShape)
print("Saving grid assignment file %s..." % a.OUTPUT_FILE)
makeDir(a.OUTPUT_FILE)
np.savetxt(a.OUTPUT_FILE, grid, delimiter=",")
print("Done.")
samples = samples[:GRID_COUNT]
elif sampleCount < GRID_COUNT:
print(
"Not enough samples (%s) for the grid you want (%s x %s = %s). Exiting."
% (sampleCount, GRID_W, GRID_H, GRID_COUNT))
sys.exit()
# prep values
for i, s in enumerate(samples):
for p in PROPS:
value = s[p]
if p == "hz":
value = math.log(value)
value *= 1000.0
samples[i]["_" + p] = value
xy = [[s["_" + PROP1], s["_" + PROP2]] for s in samples]
# pprint(xy)
# sys.exit()
xy = np.array(xy)
print("Determining grid assignment...")
gridAssignment = rasterfairy.transformPointCloud2D(xy, target=(GRID_W, GRID_H))
grid, gridShape = gridAssignment
for i, s in enumerate(samples):
gridX, gridY = grid[i]
samples[i][OUT_PROP1] = int(gridX)
samples[i][OUT_PROP2] = int(gridY)
writeCsv(OUTPUT_FILE, samples, headings=fieldNames)
def fit_transform(X):
return rasterfairy.transformPointCloud2D(X[:, :2])[0]
