How to use tensorboard - 10 common examples

ON Tensors.rowid = T1.tensor_rowid
                WHERE
                  series = (
                    SELECT tag_id
                    FROM Runs
                    CROSS JOIN Tags USING (run_id)
                    WHERE Runs.run_name = :run AND Tags.tag_name = :tag)
                  AND step IS NOT NULL
                  AND dtype = :dtype
                  /* Should be n-vector, n >= 3: [width, height, samples...] */
                  AND (NOT INSTR(shape, ',') AND CAST (shape AS INT) >= 3)
                  AND T0.idx = 0
                  AND T1.idx = 1
                ORDER BY step
                """,
                {"run": run, "tag": tag, "dtype": tf.string.as_datatype_enum},
            )
            return [
                {
                    "wall_time": computed_time,
                    "step": step,
                    "width": width,
                    "height": height,
                    "query": self._query_for_individual_image(
                        run, tag, sample, index
                    ),
                }
                for index, (computed_time, step, width, height) in enumerate(
                    cursor
                )
            ]
        response = []

model.cuda(args.gpu)
    if args.optimizer == 'adam':
        optimizer_class = optim.Adam
    elif args.optimizer == 'adagrad':
        optimizer_class = optim.Adagrad
    elif args.optimizer == 'adadelta':
        optimizer_class = optim.Adadelta
    elif args.optimizer == 'SGD':
        optimizer_class = optim.SGD
    params = [p for p in model.parameters() if p.requires_grad]
    optimizer = optimizer_class(params=params, lr=args.lr, weight_decay=args.l2reg)
    scheduler = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, mode='max', factor=0.5, patience=10, verbose=True)
    criterion = nn.CrossEntropyLoss()
    trpack = [model, params, criterion, optimizer]

    train_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(args.save_dir, 'log', 'train'), flush_secs=10)
    valid_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(args.save_dir, 'log', 'valid'), flush_secs=10)
    tsw, vsw = train_summary_writer, valid_summary_writer

    num_train_batches = data.train_size // data.batch_size 
    logging.info(f'num_train_batches: {num_train_batches}')
    validate_every = num_train_batches // 10
    best_vaild_accuacy = 0
    iter_count = 0
    tic = time.time()

    for epoch_num in range(args.max_epoch):
        for batch_iter, train_batch in enumerate(data.train_minibatch_generator()):
            progress = epoch_num + batch_iter/num_train_batches
            iter_count += 1

if args.gpu > -1:
        logging.info(f'Using GPU {args.gpu}')
        model.cuda(args.gpu)
    if args.optimizer == 'adam':
        optimizer_class = optim.Adam
    elif args.optimizer == 'adagrad':
        optimizer_class = optim.Adagrad
    elif args.optimizer == 'adadelta':
        optimizer_class = optim.Adadelta
    params = [p for p in model.parameters() if p.requires_grad]
    optimizer = optimizer_class(params=params, weight_decay=args.l2reg)
    scheduler = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, mode='max', factor=0.5, patience=20, verbose=True)
    criterion = nn.CrossEntropyLoss()
    trpack = [model, params, criterion, optimizer]

    train_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(args.save_dir, 'log', 'train'), flush_secs=10)
    valid_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(args.save_dir, 'log', 'valid'), flush_secs=10)
    tsw, vsw = train_summary_writer, valid_summary_writer

    num_train_batches = len(train_loader)
    logging.info(f'num_train_batches: {num_train_batches}')
    validate_every = num_train_batches // 10
    best_vaild_accuacy = 0
    iter_count = 0
    tic = time.time()

    for batch_iter, train_batch in enumerate(train_loader):
        progress = train_loader.epoch
        if progress > args.max_epoch:
            break

model.cuda(args.gpu)
    if args.optimizer == 'adam':
        optimizer_class = optim.Adam
    elif args.optimizer == 'adagrad':
        optimizer_class = optim.Adagrad
    elif args.optimizer == 'adadelta':
        optimizer_class = optim.Adadelta
    params = [p for p in model.parameters() if p.requires_grad]
    optimizer = optimizer_class(params=params, weight_decay=args.l2reg)
    scheduler = lr_scheduler.ReduceLROnPlateau(optimizer=optimizer, mode='max', factor=0.5, patience=20, verbose=True)
    criterion = nn.CrossEntropyLoss()
    trpack = [model, params, criterion, optimizer]

    train_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(args.save_dir, 'log', 'train'), flush_secs=10)
    valid_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(args.save_dir, 'log', 'valid'), flush_secs=10)
    tsw, vsw = train_summary_writer, valid_summary_writer

    num_train_batches = len(train_loader)
    logging.info(f'num_train_batches: {num_train_batches}')
    validate_every = num_train_batches // 10
    best_vaild_accuacy = 0
    iter_count = 0
    tic = time.time()

    for batch_iter, train_batch in enumerate(train_loader):
        progress = train_loader.epoch
        if progress > args.max_epoch:
            break
        iter_count += 1
        ################################# train iteration ####################################

self.mock_debugger_data_server = tf.compat.v1.test.mock.Mock(
            debugger_server_lib.DebuggerDataServer
        )
        self.mock_debugger_data_server_class = tf.compat.v1.test.mock.Mock(
            debugger_server_lib.DebuggerDataServer,
            return_value=self.mock_debugger_data_server,
        )

        tf.compat.v1.test.mock.patch.object(
            debugger_server_lib,
            "DebuggerDataServer",
            self.mock_debugger_data_server_class,
        ).start()

        self.context = base_plugin.TBContext(
            logdir=self.log_dir, multiplexer=multiplexer
        )
        self.plugin = debugger_plugin.DebuggerPlugin(self.context)
        self.plugin.listen(self.debugger_data_server_grpc_port)
        wsgi_app = application.TensorBoardWSGI([self.plugin])
        self.server = werkzeug_test.Client(wsgi_app, wrappers.BaseResponse)

        # The debugger data server should be started at the correct port.
        self.mock_debugger_data_server_class.assert_called_once_with(
            self.debugger_data_server_grpc_port, self.log_dir
        )

        mock_debugger_data_server = self.mock_debugger_data_server
        start = (
            mock_debugger_data_server.start_the_debugger_data_receiving_server
        )

ckpt = tf.train.Checkpoint(embeddings=embeddings)
checkpoint_file = output_dir + "/embeddings.ckpt"
ckpt.save(checkpoint_file)

reader = tf.train.load_checkpoint(output_dir)
variable_shape_map = reader.get_variable_to_shape_map()
key_to_use = ""
for key in variable_shape_map:
    if "embeddings" in key:
        key_to_use = key

config = projector.ProjectorConfig()
embedding = config.embeddings.add()
embedding.tensor_name = key_to_use

projector.visualize_embeddings(output_dir, config)

#%% Evaluate model
scores = model.evaluate(X_test, y_test, verbose=1)
print(f"Accuracy: {scores[1]:.2%}")

#%% Train with binary crossentropy and gram matrix
accuracies = []
for i in range(1, 21):
    kernel = Lambda(lambda inputs: tf.reduce_sum(inputs[0] * inputs[1], axis=1))
    model = Sequential([BasicCNN((32, 32, 3), i), GramMatrix(kernel)])
    model.summary()
    model.compile(
        optimizer="adam", loss=BinaryCrossentropy(), metrics=[class_consistency_loss, min_eigenvalue],
    )
    model.fit(X_train, y_train, validation_split=0.2, epochs=20, batch_size=32)

Args:
      logdir: A log directory that contains event files.
      event_file: Or, a particular event file path.
      tag: An optional tag name to query for.

    Returns:
      A list of InspectionUnit objects.
    """
    if logdir:
        subdirs = io_wrapper.GetLogdirSubdirectories(logdir)
        inspection_units = []
        for subdir in subdirs:
            generator = itertools.chain(
                *[
                    generator_from_event_file(os.path.join(subdir, f))
                    for f in tf.io.gfile.listdir(subdir)
                    if io_wrapper.IsTensorFlowEventsFile(
                        os.path.join(subdir, f)
                    )
                ]
            )
            inspection_units.append(
                InspectionUnit(
                    name=subdir,
                    generator=generator,
                    field_to_obs=get_field_to_observations_map(generator, tag),
                )
            )
        if inspection_units:
            print(
                "Found event files in:\n{}\n".format(
                    "\n".join([u.name for u in inspection_units])

def train(args):
    experiment_name = (f'w{args.word_dim}_lh{args.lstm_hidden_dims}'
                       f'_mh{args.mlp_hidden_dim}_ml{args.mlp_num_layers}'
                       f'_d{args.dropout_prob}')
    save_dir = os.path.join(args.save_root_dir, experiment_name)
    train_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(save_dir, 'log', 'train'))
    valid_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(save_dir, 'log', 'valid'))

    lstm_hidden_dims = [int(d) for d in args.lstm_hidden_dims.split(',')]

    logging.info('Loading data...')
    text_field = data.Field(lower=True, include_lengths=True,
                            batch_first=False)
    label_field = data.Field(sequential=False)
    if not os.path.exists(args.data_dir):
        os.makedirs(args.data_dir)
    dataset_splits = datasets.SNLI.splits(
        text_field=text_field, label_field=label_field, root=args.data_dir)
    text_field.build_vocab(*dataset_splits, vectors=args.pretrained)
    label_field.build_vocab(*dataset_splits)
    train_loader, valid_loader, _ = data.BucketIterator.splits(
        datasets=dataset_splits, batch_size=args.batch_size, device=args.gpu)

def train(args):
    experiment_name = (f'w{args.word_dim}_lh{args.lstm_hidden_dims}'
                       f'_mh{args.mlp_hidden_dim}_ml{args.mlp_num_layers}'
                       f'_d{args.dropout_prob}')
    save_dir = os.path.join(args.save_root_dir, experiment_name)
    train_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(save_dir, 'log', 'train'))
    valid_summary_writer = tensorboard.FileWriter(
        logdir=os.path.join(save_dir, 'log', 'valid'))

    lstm_hidden_dims = [int(d) for d in args.lstm_hidden_dims.split(',')]

    logging.info('Loading data...')
    text_field = data.Field(lower=True, include_lengths=True,
                            batch_first=False)
    label_field = data.Field(sequential=False)
    if not os.path.exists(args.data_dir):
        os.makedirs(args.data_dir)
    dataset_splits = datasets.SNLI.splits(
        text_field=text_field, label_field=label_field, root=args.data_dir)
    text_field.build_vocab(*dataset_splits, vectors=args.pretrained)
    label_field.build_vocab(*dataset_splits)

Returns:
          A werkzeug.Response application.
        """
        tag = request.args.get("tag")
        run = request.args.get("run")
        sample = int(request.args.get("sample", 0))

        events = self._multiplexer.Tensors(run, tag)
        try:
            response = self._audio_response_for_run(events, run, tag, sample)
        except KeyError:
            return http_util.Respond(
                request, "Invalid run or tag", "text/plain", code=400
            )
        return http_util.Respond(request, response, "application/json")