"""Compute 6 sequences of embeddings for three different tasks and visualiza them in 3D t-SNE. Each task has 2 sequences. """ import os import typing from absl import app from absl import flags from absl import logging import numpy as np import torch from torchkit import CheckpointManager from tqdm.auto import tqdm import utils from xirl import common from xirl.models import SelfSupervisedModel from sklearn.decomposition import PCA import matplotlib.pyplot as plt import matplotlib import timm plt.ion() # pylint: disable=logging-fstring-interpolation FLAGS = flags.FLAGS flags.DEFINE_string("experiment_path", None, "Path to model checkpoint.") flags.DEFINE_string("encoder_type", None, "Encoder: tcc or dinov2") flags.DEFINE_boolean( "restore_checkpoint", True, "Restore model checkpoint. Disabling loading a checkpoint is useful if you " "want to measure performance at random initialization.") ModelType = SelfSupervisedModel DataLoaderType = typing.Dict[str, torch.utils.data.DataLoader] def _gen_emb_plot(embs): """Create a pyplot plot and save to buffer.""" markers = ['o', 'o', '^', '^', 's', 's']#, 'p', '*', 'D', 'X', 'v', '<', '>'] fig = plt.figure(dpi=600) ax = fig.add_subplot(111, projection='3d') for i, emb in enumerate(embs): marker = markers[i % len(markers)] ax.scatter(emb[:, 0], emb[:, 1], emb[:, 2], label=f"Sequence {i+1}", marker=marker)#, s=0.5 fig.canvas.draw() img_arr = np.array(fig.canvas.renderer.buffer_rgba())[:, :, :3] # plt.show() # input("Press the Enter key to continue: ") # plt.close() return img_arr def setup(): """Load the latest embedder checkpoint and dataloaders.""" config = utils.load_config_from_dir(FLAGS.experiment_path) model = common.get_model(config) downstream_loaders = common.get_downstream_dataloaders(config, False)["train"] pretraining_loaders = common.get_pretraining_dataloaders(config, False)["train"] checkpoint_dir = os.path.join(FLAGS.experiment_path, "checkpoints") if FLAGS.restore_checkpoint: checkpoint_manager = CheckpointManager(checkpoint_dir, model=model) global_step = checkpoint_manager.restore_or_initialize() logging.info("Restored model from checkpoint %d.", global_step) else: logging.info("Skipping checkpoint restore.") return model, downstream_loaders def embed( model, downstream_loader, device, ): """Embed the stored trajectories.""" seq_embs = [] for class_name, class_loader in downstream_loader.items(): count = 0 logging.info("Embedding %s.", class_name) for batch in tqdm(iter(class_loader), leave=False): out = model.infer(batch["frames"].to(device), class_name) emb = out.numpy().embs if count <= 1: emb_3d = PCA(n_components=3, random_state=0).fit_transform(emb) seq_embs.append(emb_3d) count += 1 seq_lens = [s.shape[0] for s in seq_embs] min_len = np.min(seq_lens) same_length_embs = [] for emb in seq_embs: emb_len = len(emb) stride = emb_len / min_len idxs = np.arange(0.0, emb_len, stride).round().astype(int) idxs = np.clip(idxs, a_min=0, a_max=emb_len - 1) idxs = idxs[:min_len] same_length_embs.append(emb[idxs]) return same_length_embs, min_len def tcc_enc_plot(): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model, downstream_loader = setup() model.to(device).eval() traj, min_len = embed(model, downstream_loader, device) return traj, min_len def setup_dinov2(): encoder = torch.hub.load('facebookresearch/dinov2', 'dinov2_vits14') del encoder.head import timm encoder.pos_embed.data = timm.layers.pos_embed.resample_abs_pos_embed( encoder.pos_embed.data, [16, 16], ) encoder.head = torch.nn.Identity() for param in encoder.parameters(): param.requires_grad = False encoder.eval() print("Restored pretrained dinov2 model.") return encoder def embed_dinov2( model, downstream_loader, device, ): """Embed the stored trajectories.""" from torchvision import transforms as T, utils seq_embs = [] for class_name, class_loader in downstream_loader.items(): count = 0 logging.info("Embedding %s.", class_name) print(class_name) for batch in tqdm(iter(class_loader), leave=False): resize_transform = T.Resize((224, 224), interpolation=T.InterpolationMode.BICUBIC) frames = resize_transform(batch["frames"].to(device).squeeze()) out = model(frames) emb = out.cpu().numpy() if count <= 1: emb_3d = PCA(n_components=3, random_state=0).fit_transform(emb) seq_embs.append(emb_3d) count += 1 seq_lens = [s.shape[0] for s in seq_embs] min_len = np.min(seq_lens) same_length_embs = [] for emb in seq_embs: emb_len = len(emb) stride = emb_len / min_len idxs = np.arange(0.0, emb_len, stride).round().astype(int) idxs = np.clip(idxs, a_min=0, a_max=emb_len - 1) idxs = idxs[:min_len] same_length_embs.append(emb[idxs]) return same_length_embs, min_len def dinov2_enc_plot(): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") _, downstream_loader = setup() model = setup_dinov2() model.to(device).eval() traj, min_len = embed_dinov2(model, downstream_loader, device) return traj, min_len def main(_): encoder_type = FLAGS.encoder_type if encoder_type == 'tcc': traj, min_len = tcc_enc_plot() if encoder_type == 'dinov2': traj, min_len = dinov2_enc_plot() # rand_tasks_idx = np.random.randint(0, len(traj)//2, size=3) rand_tasks_idx = [7,8,9] seq_to_vis = np.ones((6, min_len, 3)) for i in range(len(rand_tasks_idx)): seq_to_vis[i*2] = traj[rand_tasks_idx[i]*2] seq_to_vis[i*2+1] = traj[rand_tasks_idx[i]*2+1] print(i*2, rand_tasks_idx[i]*2) print(i*2+1, rand_tasks_idx[i]*2+1) image = _gen_emb_plot(seq_to_vis) if encoder_type == 'tcc': matplotlib.image.imsave(f'/home/lei/Downloads/seq_vis_3tasks_{encoder_type}_{FLAGS.experiment_path.split("/")[-1]}.png', image) else: matplotlib.image.imsave(f'/home/lei/Downloads/seq_vis_3tasks_{encoder_type}.png', image) if __name__ == "__main__": flags.mark_flag_as_required("encoder_type") flags.mark_flag_as_required("experiment_path") app.run(main)