def __init__(self, config): self.default_device = "cpu" if torch.cuda.is_available(): self.default_device = "cuda" # Set Hyperparameters self.batch_size_schedule = config.train_config.batch_size_schedule self.dataset = config.dataset self.learning_rate = config.train_config.learning_rate self.running_average_generator_decay = config.models.generator.running_average_decay self.full_validation = config.use_full_validation self.load_fraction_of_dataset = config.load_fraction_of_dataset # Image settings self.current_imsize = 4 self.image_channels = config.models.image_channels self.latent_size = config.models.latent_size self.max_imsize = config.max_imsize # Logging variables self.checkpoint_dir = config.checkpoint_dir self.model_name = self.checkpoint_dir.split("/")[-2] self.config_path = config.config_path self.global_step = 0 # Transition settings self.transition_variable = 1. self.transition_iters = config.train_config.transition_iters self.is_transitioning = False self.transition_step = 0 self.start_channel_size = config.models.start_channel_size self.latest_switch = 0 self.opt_level = config.train_config.amp_opt_level self.start_time = time.time() self.discriminator, self.generator = init_model( self.latent_size, self.start_channel_size, self.image_channels) self.init_running_average_generator() self.criterion = loss.WGANLoss(self.discriminator, self.generator, self.opt_level) self.logger = logger.Logger(config.summaries_dir, config.generated_data_dir) self.num_skipped_steps = 0 if not self.load_checkpoint(): self.init_optimizers() self.batch_size = self.batch_size_schedule[self.current_imsize] self.logger.log_variable("stats/batch_size", self.batch_size) self.num_ims_per_log = config.logging.num_ims_per_log self.next_log_point = self.global_step self.num_ims_per_save_image = config.logging.num_ims_per_save_image self.next_image_save_point = self.global_step self.num_ims_per_checkpoint = config.logging.num_ims_per_checkpoint self.next_validation_checkpoint = self.global_step self.static_latent_variable = self.generator.generate_latent_variable( 64) self.dataloader_train = load_dataset(self.dataset, self.batch_size, self.current_imsize, self.full_validation, self.load_fraction_of_dataset)
def setUp(self): test_shape = ((-1, -.5, 0, .5, 1), (-2, 0, 2, 4)) self.tgrid = np.ones((5, 4)) self.gspec = grid.CartesianGridSpec(test_shape) self.grid = grid.GridScalar(self.gspec, self.tgrid) self.logg = logger.Logger() self.vis = vis.VisGif2d(r"tests/test_outs/") #instantiate many items in the log_list for i in range(50): self.logg.log(i, self.grid + i)
def setUp(self): test_shape = ((-1, -.5, 0, .5, 1), (-2, 0, 2, 4)) self.tgrid = np.ones((5, 4)) self.tgrid[3, 2] = 12 self.tgrid[1, 1] = 5 self.gspec = grid.CartesianGridSpec(test_shape) self.grid = grid.GridScalar(self.gspec, self.tgrid) self.logg = logger.Logger() #instantiate two items in the log_list self.logg.log(0., self.grid) self.logg.log(3., self.grid)
def __init__(self): self.initFile = open('./config/init.json').read() self.initData = json.loads(self.initFile) self.serverIP = self.initData['server']['IP'] self.serverPort = self.initData['server']['PORT'] self.logpath = self.initData['config']['LogPath'] self.reqNet = reqnet.ReqNet(self.serverIP, self.serverPort) self.ruleData = self.getRule() self.logger = logger.Logger(self.logpath)
import discord import os import datetime #import src from src import logger from src import msghandler from src import charownership from src import db as saved_dictionary client = discord.Client() log = logger.Logger() db = saved_dictionary.Saved_Dict.load_db() VERSION = "20210322.2116" msghandler.VERSION = VERSION msghandler.db = db charownership.db = db charownership.load_chars() command_map = { 'info': msghandler.handle_info, 'fate': msghandler.handle_fate, 'r': msghandler.handle_roll, 'roll': msghandler.handle_roll, 'p': msghandler.handle_probability, 'prob': msghandler.handle_probability, 'become': msghandler.handle_become, 'iam': msghandler.handle_become, 'tellme': msghandler.handle_tellme, 'dmg': msghandler.handle_damage, 'damage': msghandler.handle_damage, 'heal': msghandler.handle_heal,
from src import logger log = logger.Logger("TestLogger") for i in range(10): log.random_log("testing random log", logger.Level.WARNING) log.trace("Trace check") log.debug("Debug check") log.info("Info check") log.warning("Warning check") log.error("Error check") print() log.set_level(logger.Level.TRACE) log.trace("H") log.debug("E") log.info("L") log.warning("L") log.error("0") print() log.config(time=True, file=True, level=False) log.trace("B") log.debug("Y") log.info("E") log.filename = "logs.log" log.config(time=True, file=True, level=True, mode="w") log.trace("Trace check") log.debug("Debug check")
# define the callback for GCP def cb(message): print(message.data.decode('utf-8')) message.ack() # if the message is the end message, kill the remote if pipeline_complete_msg in message.data.decode('utf-8'): gcp_setup_instance.teardown() print('Exiting...') sys.exit(0) # define the function to run on keyboard interrupt inside the logger def ki(): print('\nKeyboardInterrupt. Killing remote process') print('DO NOT PERFORM ANOTHER KEYBOARD INTERRUPT') print( 'If you do, you may need to manually delete the VM instance from your GCP Compute Engine' ) print('Beginning teardown...') gcp_setup_instance.teardown() print('Exiting...') sys.exit(1) # start up the logger l = logger.Logger('consumer') l.consume(callback=cb, keyboard_interrupt=ki) # otherwise just run run.py else: subprocess.run(['python', 'src/run.py'])
laplace_op = gridoperator.GridOperator(gspec, initializer.laplace_scheme) ops_dict = {'laplacian': laplace_op} #set each of the boundaries (using all dirichlet zero for now) BCs = [] # BCs.append(static_bcs.Dirichlet(0,'l',np.array([1]))) # BCs.append(static_bcs.Dirichlet(0,'r',np.array([0]))) BCs.append(static_bcs.Dirichlet(0,'l',np.zeros(grid_u.shape[0]))) BCs.append(static_bcs.Dirichlet(0,'r',np.zeros(grid_u.shape[0]))) BCs.append(static_bcs.Dirichlet(1,'l',np.zeros(grid_u.shape[0]))) BCs.append(static_bcs.Dirichlet(1,'r',np.zeros(grid_u.shape[0]))) bound_handlr = dirichlet_hand.DirichletHand(BCs) data_logger = logger.Logger() time_stpr = forward_euler.ForwardEuler() prblm = conduct_heat_eqn.ConductHeatEqn(bound_handlr, alpha=0.05) prblm.set_ops(ops_dict) space_drive = spatial_driver.SpatialDriver(prblm, data_logger) drive = driver.Driver(space_drive, time_stpr) drive.full_solve(initializer.t_start, initializer.t_end, initializer.dt, grid_u) visualizer = plot_end.PlotEnd(initializer.out_loc)