def loop_section(): for step in logger.loop(range(0, 10)): with logger.section("Step"): time.sleep(0.5) with logger.section("Step2"): time.sleep(0.1) logger.write() logger.new_line()
def loop(self): # Loop through the monitored iterator for epoch in logger.loop(range(0, self.__epochs)): self._train() self._test() self.__log_model_params() # Clear line and output to console logger.write() # Clear line and go to the next line; # that is, we add a new line to the output # at the end of each epoch if (epoch + 1) % self.__log_new_line_interval == 0: logger.new_line() if self.__is_save_models: logger.save_checkpoint()
def main(): args = parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") kwargs = {'num_workers': 1, 'pin_memory': True} if use_cuda else {} # Loading data with logger.section("Loading data"): train_loader = torch.utils.data.DataLoader(datasets.MNIST( './data', train=True, download=True, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])), batch_size=args.batch_size, shuffle=True, **kwargs) test_loader = torch.utils.data.DataLoader( datasets.MNIST('./data', train=False, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])), batch_size=args.test_batch_size, shuffle=True, **kwargs) # Model creation with logger.section("Create model"): model = Net().to(device) optimizer = optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) # Specify indicators logger.add_indicator("train_loss", queue_limit=10, is_print=True) logger.add_indicator("test_loss", is_histogram=False, is_print=True) logger.add_indicator("accuracy", is_histogram=False, is_print=True) for name, param in model.named_parameters(): if param.requires_grad: logger.add_indicator(name, is_histogram=True, is_print=False) logger.add_indicator(f"{name}_grad", is_histogram=True, is_print=False) # Start the experiment EXPERIMENT.start_train() # Loop through the monitored iterator for epoch in logger.loop(range(0, args.epochs)): # Delayed keyboard interrupt handling to use # keyboard interrupts to end the loop. # This will capture interrupts and finish # the loop at the end of processing the iteration; # i.e. the loop won't stop in the middle of an epoch. try: with logger.delayed_keyboard_interrupt(): # Training and testing train(args, model, device, train_loader, optimizer, epoch) test(model, device, test_loader) # Add histograms with model parameter values and gradients for name, param in model.named_parameters(): if param.requires_grad: logger.store(name, param.data.cpu().numpy()) logger.store(f"{name}_grad", param.grad.cpu().numpy()) # Clear line and output to console logger.write() # Output the progress summaries to `trial.yaml` and # to the python file header logger.save_progress() # Clear line and go to the next line; # that is, we add a new line to the output # at the end of each epoch logger.new_line() # Handled delayed interrupt except KeyboardInterrupt: logger.finish_loop() logger.new_line() logger.log("\nKilling loop...") break
is_histogram=False, is_print=False, is_pair=True) # Create a TensorFlow session with tf.Session() as session: # Start the experiment from scratch, without loading from a # saved checkpoint ('is_init=True') # This will clear all the old checkpoints and summaries for this # experiment. # If you start with 'is_init=False', # the experiment will load from the last saved checkpoint. EXPERIMENT.start_train(session, is_init=True) # This is the main training loop of this project. for global_step in logger.loop(range(50)): # You can set the global step explicitly with # 'logger.set_global_step(global_step)' # Handle Keyboard Interrupts try: with logger.delayed_keyboard_interrupt(): # A sample monitored section inside iterator with logger.section("sample"): time.sleep(0.5) # A silent section is used only to organize code. # It produces no output with logger.section("logging", is_silent=True): # Store values logger.store(reward=global_step / 3.0, fps=12)
def main(): args = parse_args() # Loading data with logger.section("Load data"): mnist = tf.keras.datasets.mnist (x_train, y_train), (x_test, y_test) = mnist.load_data() x_train, x_test = x_train / 255.0, x_test / 255.0 train_dataset = create_mnist_dataset(x_train, y_train, args.batch_size) test_dataset = create_mnist_dataset(x_test, y_test, args.batch_size) # Model creation with logger.section("Create model"): model = tf.keras.models.Sequential([ tf.keras.layers.Flatten(input_shape=(28, 28)), tf.keras.layers.Dense(512, activation=tf.nn.relu), tf.keras.layers.Dropout(0.2), tf.keras.layers.Dense(10, activation=tf.nn.softmax) ]) # Creation of the trainer with logger.section("Create trainer"): optimizer = tf.train.AdamOptimizer(learning_rate=args.lr) train_iterator = train_dataset.make_initializable_iterator() data, target = train_iterator.get_next() train_loss = loss(model, data, target) train_op = optimizer.minimize(train_loss) test_iterator = test_dataset.make_initializable_iterator() data, target = test_iterator.get_next() test_loss = loss(model, data, target) test_accuracy = accuracy(model, data, target) logger.add_indicator("train_loss", queue_limit=10, is_print=True) logger.add_indicator("test_loss", is_histogram=False, is_print=True) logger.add_indicator("accuracy", is_histogram=False, is_print=True) # batches = len(x_train) // args.batch_size with tf.Session() as session: EXPERIMENT.start_train(session) # Loop through the monitored iterator for epoch in logger.loop(range(0, args.epochs)): # Delayed keyboard interrupt handling to use # keyboard interrupts to end the loop. # This will capture interrupts and finish # the loop at the end of processing the iteration; # i.e. the loop won't stop in the middle of an epoch. try: with logger.delayed_keyboard_interrupt(): # Training and testing session.run(train_iterator.initializer) train(args, session, train_loss, train_op, batches, epoch) session.run(test_iterator.initializer) test(session, test_loss, test_accuracy, len(x_test) // args.batch_size) # Clear line and output to console logger.write() # Output the progress summaries to `trial.yaml` and # to the python file header logger.save_progress() # Clear line and go to the next line; # that is, we add a new line to the output # at the end of each epoch logger.new_line() # Handled delayed interrupt except KeyboardInterrupt: logger.finish_loop() logger.new_line() logger.log("\nKilling loop...") break
def loop_partial_section(): for step in logger.loop(range(0, 10)): with logger.section("Step", is_partial=True): time.sleep(0.5) logger.progress((step % 5 + 1) / 5) logger.write()