class TbLogger():
def __init__(self, logdir, unique_dir=False, restart=False):
if restart:
subdirectories = [f.path for f in os.scandir(logdir) if f.is_dir()]
for dir in subdirectories:
shutil.rmtree(dir)
if unique_dir:
logdir = os.path.join(
logdir, str(datetime.datetime.today().strftime('%d. %B %Y')))
print(logdir)
self.writer = SummaryWriter(logdir)
def add_image(self, title, image, global_step=None):
self.writer.add_image(title, image, global_step)
def add_graph(self, net, image, verbose=False):
self.writer.add_graph(net, image, verbose)
def add_embedding(self, features, metadata, label_img, global_step=None):
self.writer.add_embedding(features,
metadata,
label_img,
global_step=global_step)
def add_scalar(self, var, val, global_step=None):
self.writer.add_scalar(var, val, global_step)
def add_figure(self, var, image, global_step=None):
self.writer.add_figure(var, image, global_step)
def close(self):
self.writer.close()
def create_3d_projector(loader, num, net, logdir, cm):
try:
classes = list(loader.dataset.class_to_idx.keys())
except:
classes = list(loader.dataset.dataset.class_to_idx.keys())
with torch.no_grad():
for data in loader:
images, labels = data
images = images.to(device)
outputs = net(images)
_, predictions = torch.max(outputs.to('cpu').data, 1)
class_labels = [classes[lab] for lab in labels]
features = net.output_final_layer.to('cpu')
break
images = images.to('cpu')
# print(images.shape)
try:
_, _, _, _ = images.shape
# images_new = images.permute(0,3,1,2)
images_new = images
except:
images_new = images.unsqueeze(1)
if cm == True:
create_image_confusion_matrix(logdir, labels.numpy(),
predictions.numpy(), classes)
writer = SummaryWriter(logdir)
writer.add_embedding(features, metadata=class_labels, label_img=images_new)
writer.close()
def add_embedding_visualization(writer: SummaryWriter, metrics, global_step):
all_embeddings, all_image_data, all_targets = metrics['embedding_data']
writer.add_embedding(all_embeddings,
metadata=all_targets,
label_img=all_image_data,
global_step=global_step,
tag="coord2vec")
def test(args, mnasnet, regressor, data_loader, show_image_on_board=True):
writer = SummaryWriter()
weights = []
images = []
labels = []
result_labels = []
with torch.no_grad():
for i, (image, label) in enumerate(data_loader):
image = image.to(device)
images.append(image.squeeze(0).numpy())
label = label.squeeze(0).numpy()[0]
labels.append(label)
x = mnasnet(image)
out_cl, emb = regressor.predict(x)
out_label = out_cl.argmax(dim=1, keepdim=True)
# visualize(args, image, predict, i, label, out_label)
result_labels.append(out_label)
weights.append(emb.squeeze(0).numpy())
weights = torch.FloatTensor(weights)
images = torch.FloatTensor(images)
if show_image_on_board:
writer.add_embedding(weights, label_img=images)
else:
writer.add_embedding(weights, metadata=labels)
print_result(labels, result_labels)
print("done")
class _Visualizer():
"""
Class that define utility functions to use TensorBoard as visualization debug platform
"""
def __init__(self,
log_dir="./visualizer_logs",
flush_secs=120,
filename_suffix='adaptation_'):
self.timestamp = datetime.now()
self.writer = SummaryWriter(log_dir=log_dir,
flush_secs=flush_secs,
filename_suffix=filename_suffix,
comment=str(self.timestamp))
def add_embedding(self, vectors, metadata, metadata_header, tag=None):
"""
Append given embeddings and informations to SummaryWriter
@param vectors: list of embeddings' matrix
@param metadata: list of records that describe the correspondent vector
@param metadata_header: header of metadata columns
@return None
"""
if not tag:
tag = "main_" + str(datetime.now())
vectors = np.array(vectors)
self.writer.add_embedding(vectors,
metadata,
metadata_header=metadata_header,
global_step=tag)
def close(self):
self.writer.close()
class Tensorboard:
def __init__(self, config: ConfigFactory) -> None:
self.config = config
self.writer = SummaryWriter(self.config.tensorboard_path())
def write_scalar(self, title, value, iteration) -> None:
self.writer.add_scalar(title, value, iteration)
def write_video(self, title, value, iteration) -> None:
self.writer.add_video(title,
value,
global_step=iteration,
fps=self.config.fps)
def write_image(self, title, value, iteration) -> None:
self.writer.add_image(title,
value,
global_step=iteration,
dataformats='CHW')
def write_histogram(self, title, value, iteration) -> None:
self.writer.add_histogram(title, value, iteration)
def write_embedding(self, all_embeddings, metadata, images) -> None:
self.writer.add_embedding(all_embeddings,
metadata=metadata,
label_img=images)
def write_embedding_no_labels(self, all_embeddings, images) -> None:
self.writer.add_embedding(all_embeddings, label_img=images)
def evaluate_encoder(encoder: nn.Module,
test_loader: torch.utils.data.DataLoader,
loss_fn: nn.TripletMarginLoss = None,
writer: SummaryWriter = None,
epoch: int = -1):
with torch.no_grad():
encoder.eval()
searcher = Searcher.get_simple_index(encoder.embedding_dim)
embeddings_x = []
embeddings_y = []
epoch_losses = []
for step, (x, y_pos, y_neg) in enumerate(test_loader):
x, y_pos, y_neg = x.cuda(), y_pos.cuda(), y_neg.cuda()
x_enc = encoder(x)
y_pos_enc = encoder(y_pos)
y_neg_enc = encoder(y_neg)
if loss_fn:
loss_val = loss_fn(x_enc, y_pos_enc, y_neg_enc)
epoch_losses.append(loss_val.item())
embeddings_x.append(x_enc)
embeddings_y.append(y_pos_enc)
print(' Test batch {} of {}'.format(step + 1, len(test_loader)),
file=sys.stderr)
embeddings_x = torch.cat(embeddings_x, dim=0)
embeddings_y = torch.cat(embeddings_y, dim=0)
searcher.add(embeddings_x)
lookup = searcher.search(embeddings_y, 100)
correct_100 = sum(y in x
for y, x in enumerate(lookup[1])) / len(lookup[1])
correct_50 = sum(y in x[:50]
for y, x in enumerate(lookup[1])) / len(lookup[1])
correct_10 = sum(y in x[:10]
for y, x in enumerate(lookup[1])) / len(lookup[1])
correct_1 = sum(y == x[0]
for y, x in enumerate(lookup[1])) / len(lookup[1])
print(f'Test loss: {np.mean(epoch_losses):.4f}')
print(
'Test accuracy:\n top1 {}\n top10 {}\n top50 {}\n top100 {}'
.format(correct_1, correct_10, correct_50, correct_100))
if writer:
writer.add_scalars('Accuracy', {
'top1': correct_1,
'top10': correct_10,
'top50': correct_50,
'top100': correct_100,
},
global_step=epoch)
writer.add_scalar('Loss/test',
np.mean(epoch_losses),
global_step=epoch)
if epoch == -1 or epoch % 5 == 1:
mat = torch.cat([embeddings_x[:1000], embeddings_y[:1000]],
dim=0)
labels = list(range(1000)) + list(range(1000))
writer.add_embedding(mat,
labels,
tag='Embeddings',
global_step=epoch)
return correct_1 * 100, correct_100 * 100, lookup, embeddings_x, embeddings_y
def make_embeddings(args):
"""
Make embeddings from 'args.wav_dir', save them into Annoy and TF Projector and JIT-compile their model.
"""
coubs = sorted(args.wav_dir.glob('*.wav'))
coub_dataset = ConcatDataset(
[boiler.dataset.WavFile(wav) for wav in coubs])
coub_loader = DataLoader(coub_dataset,
batch_size=64,
shuffle=False,
num_workers=4)
model = getattr(boiler.encoder, args.encoder)(args.pt_path, args.device)
embeddings = []
for batch in tqdm(coub_loader):
embeddings.append(model(batch.to(args.device)).detach().cpu())
gc.collect()
torch.cuda.empty_cache()
embeddings = torch.cat(embeddings)
model_dir = args.pt_path.with_suffix('') / str(args.encoder)
model_dir.mkdir(parents=True, exist_ok=True)
torch.jit.script(model).save(str(model_dir / 'encoder.pt'))
writer = SummaryWriter(log_dir=model_dir)
writer.add_embedding(
embeddings,
global_step=None,
metadata=[f'https://coub.com/view/{p.stem}' for p in coubs])
return model_dir, embeddings
def main(sigs_path, images_path, samples_per_person=16):
# Read the imagenet signatures from file
paths, signatures = read_signatures(sigs_path)
# Enumerate the frame paths based on person and video
person_ids, video_ids = enumerate_paths(paths)
# Sample "samples_per_person" images from each person
sampled_indices = [
pid for pp in split_by(range(len(paths)), person_ids)
for pid in sorted(np.random.choice(pp, samples_per_person).tolist())
]
sampled_paths = [paths[idx] for idx in sampled_indices]
sampled_labels = np.mgrid[:len(sampled_indices
), :samples_per_person][0].ravel()
# Get images of sampled data points
with Images(images_path) as images:
sampled_images = [images[path] for path in sampled_paths]
sampled_images = np.concatenate([sampled_images]).transpose([0, 3, 1, 2])
# Get normalized signatures of sampled data points
sampled_sigs = signatures[sampled_indices]
sampled_sigs /= np.sqrt(
np.sum(np.square(sampled_sigs), axis=1, keepdims=True))
# Write data to tensorboard projector
writer = SummaryWriter()
meta_data = [sp.split('/')[0] for sp in sampled_paths]
label_img = torch.from_numpy(sampled_images).float() / 255
writer.add_embedding(torch.from_numpy(sampled_sigs),
metadata=meta_data,
label_img=label_img)
print('Visualization ready')
print('run: \t tensorboard --logdir=runs')
def main():
# transforms
transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, ), (0.5, ))])
# datasets
trainset = torchvision.datasets.FashionMNIST('./data',
download=True,
train=True,
transform=transform)
testset = torchvision.datasets.FashionMNIST('./data',
download=True,
train=False,
transform=transform)
# dataloaders
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=4,
shuffle=True,
num_workers=2)
testloader = torch.utils.data.DataLoader(testset,
batch_size=4,
shuffle=False,
num_workers=2)
# constant for classes
classes = ('T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal',
'Shirt', 'Sneaker', 'Bag', 'Ankle Boot')
writer = SummaryWriter('runs/fashion_mnist_experiment_1')
dataiter = iter(trainloader)
images, labels = dataiter.next()
# create grid of images
img_grid = torchvision.utils.make_grid(images)
# show images
matplotlib_imshow(img_grid, one_channel=True)
# write to tensorboard
writer.add_image('four_fashion_mnist_images', img_grid)
net = Net()
writer.add_graph(net, images)
# select random images and their target indices
images, labels = select_n_random(trainset.data, trainset.targets)
# get the class labels for each image
class_labels = [classes[lab] for lab in labels]
# log embeddings
features = images.view(-1, 28 * 28)
writer.add_embedding(features,
metadata=class_labels,
label_img=images.unsqueeze(1))
writer.close()
class TensorboardWriter:
def __init__(self, outdir):
assert (os.path.isdir(outdir))
self.outdir = outdir
self.writer = SummaryWriter(self.outdir, flush_secs=10)
def save_scalar(self, tag, scalar_value, global_step=None):
self.writer.add_scalar(tag, scalar_value, global_step)
def save_scalars(self, main_tag, scalars_dict, global_step=None):
self.writer.add_scalars(main_tag, scalars_dict, global_step)
def save_image(self, tag, image, global_step=None, dataformats='CHW'):
self.writer.add_image(tag=tag,
img_tensor=image,
global_step=global_step,
dataformats=dataformats)
def save_figure(self, tag, figure, global_step=None, close=False):
self.writer.add_figure(tag=tag,
figure=figure,
global_step=global_step,
close=close)
def save_graph(self, model, inputs_to_model=None):
"""
Saves graph to the tensorboard. Ideally call once.
:param model: The torch.nn.Module object
:param inputs_to_model: tensor or a list of tensor(batch) will also be showed.
:return: None
"""
try:
self.writer.add_graph(model, inputs_to_model)
except Exception as e:
logger.exception(
'Check this for fix: https://github.com/lanpa/tensorboardX/issues/389#issuecomment-475879228'
)
def save_embedding(self,
mat,
metadata=None,
label_img=None,
global_step=None,
tag='default',
metadata_header=None):
self.writer.add_embedding(mat, metadata, label_img, global_step, tag,
metadata_header)
def flush(self):
"""
If you need to flush all data immediately.
"""
self.writer._get_file_writer().flush()
def close(self):
"""
To be called in the end
"""
self.writer.close()
def make_pytorch_projector(log_dir, embeddings, global_step):
''' Exports PyTorch projector '''
writer = SummaryWriter(log_dir)
writer.add_embedding(embeddings['mat'],
metadata=embeddings['labels'],
tag=embeddings['tag'],
global_step=global_step)
writer.close()
def log_embeddings_to_tensorboard(loader: DataLoader, model: nn.Module,
device: torch.device, writer: SummaryWriter,
tag: str) -> None:
if tag == "train":
if hasattr(loader.sampler, "sequential_sampling"):
loader.sampler.sequential_sampling = True
# Calculating embedding of training set for visualization
embeddings, labels = get_embeddings_from_dataloader(loader, model, device)
writer.add_embedding(embeddings, metadata=labels.tolist(), tag=tag)
def evaluate_encoder(encoder: nn.Module, test_loader: torch.utils.data.DataLoader, writer: SummaryWriter = None,
epoch: int = -1, final=False):
with torch.no_grad():
encoder.eval()
searcher = Searcher.get_simple_index(encoder.embedding_dim)
embeddings = []
targets = []
for step, (x, target) in enumerate(test_loader):
x = x.cuda()
x_enc = encoder(x)
embeddings.append(x_enc.cpu().numpy())
targets.append(target.numpy())
print(' Test batch {} of {}'.format(step + 1, len(test_loader)), file=sys.stderr)
embeddings = np.concatenate(embeddings, axis=0)
targets = np.concatenate(targets, axis=0)
searcher.add(embeddings)
lookup = searcher.search(embeddings, 100)[1]
lookup = [[x for x in l if x != i] for i, l in enumerate(lookup)]
correct_10 = sum(targets[y] in targets[x[:10]] for y, x in enumerate(lookup)) / len(lookup)
correct_1 = sum(targets[y] == targets[x[0]] for y, x in enumerate(lookup)) / len(lookup)
class_embeds = defaultdict(list)
for embed, tgt in zip(embeddings, targets):
class_embeds[tgt.item()].append(embed)
class_means = {k: np.mean(v, axis=0) for k, v in class_embeds.items()}
mean_correct_1 = 0
for embed, tgt in zip(embeddings, targets):
class_mean_without_x = np.mean([x for x in class_embeds[tgt.item()] if not np.array_equal(x, embed)],
axis=0)
best_other_val = 9999999999
for k, v in class_means.items():
if k == tgt.item():
continue
dist = ((embed - v) ** 2).sum()
if best_other_val > ((embed - v) ** 2).sum():
best_other_val = dist
if ((embed - class_mean_without_x) ** 2).sum() < best_other_val:
mean_correct_1 += 1
mean_correct_1 /= len(embeddings)
print(
'Test accuracy:\n top1 {}\n top10 {}\n mean1 {}'.format(
correct_1, correct_10, mean_correct_1))
if writer and not final:
writer.add_scalar('Accuracy/Test_top1', correct_1, global_step=epoch)
writer.add_scalar('Accuracy/Test_top10', correct_10, global_step=epoch)
writer.add_scalar('Accuracy/Test_mean1', mean_correct_1, global_step=epoch)
if epoch == -1 or epoch % 5 == 1:
mat = embeddings[:1000]
labels = targets[:1000]
writer.add_embedding(mat, labels, tag='Embeddings', global_step=epoch)
if writer and final:
writer.add_text('FinalResults',
'top_1: {}, top_2: {}, mean1: {}'.format(correct_1, correct_10, mean_correct_1))
mat = embeddings
labels = targets
writer.add_embedding(mat, labels, tag='EmbeddingsAll', global_step=epoch+1)
return correct_1 * 100, correct_10 * 100
def embed_map(embeddings, images, exp):
import tensorflow
from torch.utils.tensorboard import SummaryWriter
import tensorboard
tensorflow.io.gfile = tensorboard.compat.tensorflow_stub.io.gfile
writer = SummaryWriter(log_dir=os.path.join("./results", exp))
writer.add_embedding(embeddings, label_img=images)
writer.close()
def save_to_tensorboard(self, embeddings, save_dir):
metadata, embeds = [], []
for (name, category), person_embeds in embeddings.items():
metadata += [f'{category}: {name}'] * person_embeds.shape[0]
embeds.append(person_embeds)
embeds = np.concatenate(embeds, axis=0)
writer = SummaryWriter(log_dir=save_dir)
writer.add_embedding(embeds, metadata=metadata)
writer.close()
def train_word2vec(base_dir, train_file, embedding_dim, num_iters):
train_data_raw = pd.read_csv(train_file,
usecols=["movieId", "userId"],
na_filter=False)
try:
max_id = read_info_file(train_file.parent).get("num_items") + 1
except FileNotFoundError:
max_id = read_info_file(train_file.parent.parent).get("num_items") + 1
max_id = int(max_id)
train_data = train_data_raw.groupby("userId").agg(list).squeeze()
# Learn an unknown token embedding. Therefore we sample 50 items randomly from the long tail and mask them to one vector
items_train = np.unique(train_data_raw.movieId.values.ravel())
candidates = items_train[:int(len(items_train) / 2)]
unk_items = np.random.choice(candidates, 50, replace=False)
print("Replacing {} items with the unknown token symbol".format(unk_items))
unk_id = max_id + 1
fn = np.vectorize(lambda x: str(x) if x not in unk_items else str(unk_id))
train_data = train_data.map(lambda x: fn(x).tolist())
string_corpus = train_data.values.tolist()
print(len(list(filter(lambda x: str(unk_id) in x, string_corpus))))
logging.info("Pretraining the word2vec model")
word2vec_dir = base_dir / "word2vec"
word2vec_dir.mkdir(exist_ok=True)
for dim in embedding_dim:
dim_dir = word2vec_dir / str(dim)
dim_dir.mkdir(exist_ok=True)
writer = SummaryWriter(dim_dir)
w2v = Word2Vec(string_corpus,
size=dim,
compute_loss=True,
callbacks=[
Word2VecCallback(writer),
WordVectorDumpCallback(dim_dir, embedding_dim)
],
min_count=1,
workers=32,
iter=num_iters,
window=3)
wv = w2v.wv
embedding_tensor = torch.zeros(max_id, dim, dtype=torch.float32)
for str_id in map(str, items_train):
if str_id in wv:
embedding_tensor[int(str_id)] = torch.as_tensor(wv[str_id])
empty_indices = set(range(1, max_id)) - set(items_train)
embedding_tensor[torch.as_tensor(list(empty_indices),
dtype=torch.long)] = torch.as_tensor(
wv[str(unk_id)])
torch.save(embedding_tensor,
word2vec_dir / "tensor_{}.pkl".format(dim))
writer.add_embedding(embedding_tensor, tag=str(dim))
def writer_init(embedding_files,
image=None,
visual_name='embedding_discipline'):
writer = SummaryWriter('runs/' + visual_name)
embedding = np.load(embedding_files)
if image is not None:
image_label = np.repeat(image, embedding.shape[0]).reshape(
(-1, image.shape[0], image.shape[1], image.shape[2]))
else:
image_label = None
print(image_label.shape)
writer.add_embedding(embedding, label_img=torch.from_numpy(image_label))
def projector_word_embeddings(learn=None, layer=None, vocab=None, limit=-1, start=0, log_dir=None):
"Extracts and exports word embeddings from language models embedding layers"
if not layer:
if isinstance(learn, LMLearner): layer = learn.model[0].encoder
elif isinstance(learn, TextLearner): layer = learn.model[0].module.encoder
emb = layer.weight
img = torch.full((len(emb),3,8,8), 0.7)
vocab = learn.dls.vocab[0] if vocab == None else vocab
vocab = list(map(lambda x: f'{x}_', vocab))
writer = SummaryWriter(log_dir=log_dir)
end = start + limit if limit >= 0 else -1
writer.add_embedding(emb[start:end], metadata=vocab[start:end], label_img=img[start:end])
writer.close()
def magic():
writer = SummaryWriter()
all_files = os.listdir("backup/")
for file_ in tqdm(all_files):
pos = file_.find(".pth")
if pos > 0:
name_of_epoch = file_[:pos]
word_vectors = process_file(file_)
writer.add_embedding(word_vectors,
metadata=words,
tag=name_of_epoch)
writer.close()
def write_summary(data, output_dir):
os.system('rm -rf ' + output_dir)
os.system('mkdir ' + output_dir)
writer = SummaryWriter(output_dir)
writer.add_embedding(data['embeddings'], metadata=data['labels'])
writer.close()
# fix metadata manually
metadata_file = os.path.join(output_dir, '00000/default/metadata.tsv')
with open(metadata_file, 'w') as f:
f.write('label\ttext\n')
for label, event_text in zip(data['labels'], data['event_texts']):
f.write(str(label.item()) + '\t' + event_text + '\n')
def wordEmbedding_demo():
# 实例化写入对象
writer = SummaryWriter()
# 随机初始化一个100*5的矩阵用于演示
embedded = torch.randn(100, 5)
# 导入准备好的100个词汇
meta = list(
map(
lambda x: x.strip(),
fileinput.FileInput(
"/Users/songqinghu/Desktop/baiduyun/data/nlp/proprecess/vocab100.csv"
)))
print(meta)
writer.add_embedding(embedded, metadata=meta)
writer.close()
class VisualizerTensorboard:
def __init__(self, opts):
self.dtype = {}
self.iteration = 1
self.writer = SummaryWriter(opts.logs_dir)
def register(self, modules):
# here modules are assumed to be a dictionary
for key in modules:
self.dtype[key] = modules[key]['dtype']
def update(self, modules):
for key, value in modules:
if self.dtype[key] == 'scalar':
self.writer.add_scalar(key, value, self.iteration)
elif self.dtype[key] == 'scalars':
self.writer.add_scalars(key, value, self.iteration)
elif self.dtype[key] == 'histogram':
self.writer.add_histogram(key, value, self.iteration)
elif self.dtype[key] == 'image':
self.writer.add_image(key, value, self.iteration)
elif self.dtype[key] == 'images':
self.writer.add_images(key, value, self.iteration)
elif self.dtype[key] == 'figure':
self.writer.add_figure(key, value, self.iteration)
elif self.dtype[key] == 'video':
self.writer.add_video(key, value, self.iteration)
elif self.dtype[key] == 'audio':
self.writer.add_audio(key, value, self.iteration)
elif self.dtype[key] == 'text':
self.writer.add_text(key, value, self.iteration)
elif self.dtype[key] == 'embedding':
self.writer.add_embedding(key, value, self.iteration)
elif self.dtype[key] == 'pr_curve':
self.writer.pr_curve(key, value['labels'],
value['predictions'], self.iteration)
elif self.dtype[key] == 'mesh':
self.writer.add_audio(key, value, self.iteration)
elif self.dtype[key] == 'hparams':
self.writer.add_hparams(key, value['hparam_dict'],
value['metric_dict'], self.iteration)
else:
raise Exception(
'Data type not supported, please update the visualizer plugin and rerun !!'
)
self.iteration = self.iteration + 1
class TensorboardLogger:
def __init__(self, log_dir):
self.writer = SummaryWriter(log_dir=log_dir)
self.supported_types = [
'scalar', 'histogram', 'image', 'graph', 'embedding'
]
def save_dict(self, kvs, step):
for key in kvs.keys():
if key not in self.supported_types:
raise TypeError(f'Unsupported data type in tensorboard: {key}')
for tp in self.supported_types[:3]:
if tp in kvs:
for k, v in kvs[tp].items():
getattr(self, f'save_{tp}')(k, v, step)
for tp in self.supported_types[3:]:
if tp in kvs:
getattr(self, f'save_{tp}')(**kvs[tp])
def save_scalar(self, tag, scalar, step):
self.writer.add_scalar(tag, scalar, step)
def save_histogram(self, tag, tensor, step):
self.writer.add_histogram(tag, tensor, step)
def save_image(self, tag, tensor, step):
self.writer.add_image(tag, tensor, step)
def save_graph(self, model, input_to_model=None):
self.writer.add_graph(model, input_to_model)
def save_embedding(self,
tensor,
metadata=None,
label_img=None,
step=None,
tag='default'):
self.writer.add_embedding(tensor,
metadata=metadata,
label_img=label_img,
global_step=step,
tag=tag)
def __del__(self):
self.writer.flush()
self.writer.close()
class Logger(object):
def __init__(self, path):
self.writer = SummaryWriter(os.path.join(path, 'runs'))
def show_img_grid(self, images, info='pictures'):
"""
show a batch of images
images:a batch of tensors which are a batch of images
info:the information about the pictures
"""
img_grid = torchvision.utils.make_grid(images)
self.writer.add_image(info, img_grid)
def add_projector(self, feature, label=None, img=None):
"""
visualize the lower dimensional representation of higher dimensional data
feature:a matrix which each row is the feature vector of the data point
label:label
img:label_img
"""
self.writer.add_embedding(mat=feature, metadata=label, label_img=img)
def draw_scalars(self, tag, scalars, start_iteration=0):
"""
draw the list curve,such as loss accuracy
list:the list of values
start_iteration:the start iteration of training,default is 0,means train from scratch
"""
for i, item in enumerate(scalars):
self.writer.add_scalar(tag, item, start_iteration + i)
def add_pr_curve_tensorboard(self,
tag,
labels,
predictions,
global_step=0):
"""
Takes in a class index and plots the corresponding
precision-recall curve
"""
self.writer.add_pr_curve(tag,
labels,
predictions,
global_step=global_step)
def close(self):
self.writer.close()
def test_embedding_64(self):
w = SummaryWriter()
all_features = torch.Tensor([[1, 2, 3], [5, 4, 1], [3, 7, 7]])
all_labels = torch.Tensor([33, 44, 55])
all_images = torch.zeros((3, 3, 5, 5), dtype=torch.float64)
w.add_embedding(all_features,
metadata=all_labels,
label_img=all_images,
global_step=2)
dataset_label = ['test'] * 2 + ['train'] * 2
all_labels = list(zip(all_labels, dataset_label))
w.add_embedding(all_features,
metadata=all_labels,
label_img=all_images,
metadata_header=['digit', 'dataset'],
global_step=2)
def embeddings(
dataset_name: str, embeddings_name: str, metadata: str, tag: List[str]
) -> None:
"""Add the embeddings in the given path to Tensorboard."""
from pandas import read_csv
from vscvs.utils import sprite_tensor
classes = read_csv(metadata, delimiter="\t")["class"]
embeddings_tensor = load_embeddings(embeddings_name)
writer = SummaryWriter(get_path("tensorboard", "embeddings", embeddings_name))
writer.add_embedding(
embeddings_tensor,
metadata=classes,
tag="/".join((embeddings_name,) + tag),
label_img=sprite_tensor(dataset_name),
)
writer.close()
click.echo("Embeddings added to Tensorboard: {}".format(embeddings_name))
class EmbeddingVisualiser:
"""Visualize an embedding in tensorboard
"""
def __init__(self, df, label_cols, feat_cols, session_name=""):
self.session_name = session_name
self.labels = df[label_cols]
self.features = df[feat_cols]
self.writer = SummaryWriter(
log_dir=os.path.join('.', 'embedding', self.session_name))
def visualize(self, embeddings_folder):
self.writer.add_embedding(self.features.values,
metadata=self.labels["colors"].values,
tag="colors")
self.writer.add_embedding(self.features.values,
metadata=self.labels["is_reference"].values,
tag="Munsell points highlight")
class TensorboardWriter:
def __init__(self):
writer_path = os.path.join(config.tensorboard.tensorboard_path, config.tensorboard.experiment_name)
self.writer = SummaryWriter(writer_path)
def add_scalar(self, tag: str, x: int, y: float):
self.writer.add_scalar(tag=tag, scalar_value=y, global_step=x)
self.writer.flush()
def add_embedding(self, tag: str, features: np.ndarray, labels: np.ndarray):
assert features.shape[0] == labels.shape[0]
assert features.ndim == 2
self.writer.add_embedding(mat=features, metadata=labels, tag=tag)
self.writer.flush()
def close(self):
self.writer.close()
def test(args, mnasnet, model, data_loader, show_image_on_board=True):
writer = SummaryWriter()
images = []
labels = []
weights = []
with torch.no_grad():
for i, (image, label) in enumerate(data_loader):
image = image.to(device)
images.append(image.squeeze(0).numpy())
label = label.squeeze(0).numpy()[0]
labels.append(label)
x = mnasnet(image)
recon_x = model(x)
weights.append(x.squeeze(0).numpy())
weights = torch.FloatTensor(weights)
writer.add_embedding(weights, metadata=labels)
print("done")
