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)