def main(): args = arg_parser() if args.mode == "train": env = environment.make(args.env, args) if args.networks == "MLP": nn = MLP(env.observation_space.shape[0], env.action_space, args.n_frames) elif args.networks == "CONV": nn = CONV(args.n_frames, env.action_space) optimizer = SharedAdam(nn.parameters()) threads = [] thread = mp.Process(target=test, args=(args, nn)) thread.start() threads.append(thread) for i in range(0, args.n_workers): thread = mp.Process(target=train, args=(i, args, nn, optimizer)) thread.start() threads.append(thread) for thread in threads: thread.join() elif args.mode == "test": evaluate(args)
def main(): torch.manual_seed(SEED) args = arg_parser() dataset = MADataset(args.len_dataset, args.connectivity_path, args.task_path, args.city_path, args.reward_path, args.destination_path) data_loader = DataLoader(dataset) trainer = Trainer(args=args, n_agents=args.n_agents, n_cities=args.n_cities, device=DEVICE, data_loader=data_loader) memory = ReplayMemory(MEMORY_CAPACITY) for i in range(args.n_envs): trainer.gen_env() print("+----------------------------------------------+\n" "| Environment: {0} |\n" "+----------------------------------------------+\n".format( trainer.idx_env)) for epoch in tqdm(range(args.epochs)): epoch_reward = 0.0 trainer.optimizer.zero_grad() for step in range(args.steps): transitions = trainer.step() if transitions == "done": break epoch_reward += sum([t.reward for t in transitions]) memory.push_all(transitions) # passed all time-steps and reset trainer.env.reset() if epoch % 10 == 0: samples = memory.sample(args.batch_size) # print("\n") # print(samples) # calc maxQ(s_t+1) then calc loss loss = trainer.calc_loss(samples) loss.backward() # for param in trainer.DQN.parameters(): # param.grad.data.clamp_(-1, 1) trainer.optimizer.step() # if epoch % 100 == 0: print("\n Epoch: {0} reward: {1} loss: {2}\n".format( epoch, epoch_reward, loss.float()))
data_list_append = data_list.append tag_set = set() for child in root: data = child.attrib #body = " ".join(re.sub(_regex, ' ', data['Body']).split()) title = None if data.get('Title'): title = " ".join(re.sub(_regex, ' ', data['Title']).split()) tags = None if data.get('Tags'): tags = re.sub('<|>', ' ', data['Tags']).split() tag_set = tag_set.union(set(tags)) if title == None or tags == None: continue #data_list_append({'body': body, 'tags': tags, 'title': title}) #f = open(outfile+'.json', 'w') #dumps = json.dumps(data_list, sort_keys=True, indent=2) #f.write(dumps) #f.close() fl = open(outfile + 'tags.txt', 'w') tag_list = list(tag_set) for item in tag_list: fl.write("%s\n" % item) if __name__ == '__main__': infile, outfile = arg_parser() main(infile, outfile)
r, w, e = select.select([], clients, [], 0) except Exception as e: pass for s_client in w: srv_response = encode_json(response(200)) try: data = s_client.recv(1024) print(decode_json(data)) s_client.send(srv_response) except: clients.remove(s_client) if __name__ == '__main__': parser = arg_parser() namespace = parser.parse_args() if namespace.addr: HOST = namespace.addr PORT = namespace.port elif namespace.port: HOST = '' PORT = namespace.port else: HOST = '' PORT = 7777 print('Server started') srv_loop()
import matplotlib as plt import pdb import os import argparse from tensorboardX import SummaryWriter import time from Networks import * import utils # from dropout import create_adversarial_dropout_mask, calculate_jacobians _DIGIT_ROOT = '~/dataset/digits/' _PREFIX = '' opt = argparse.ArgumentParser() opt = utils.arg_parser(opt) opt = opt.parse_args() ### For Tensorboard # cur = time.time() # run_dir = "runs/{0}".format(curtime[0:19]) # writer = SummaryWriter(run_dir) # writer.add_image('generated', sum_img.view(3, 256, 512), epoch) # writer.add_image('generated', sum_img.view(3, 256, 512), epoch) # self.writer.add_scalar('PA', PA, self.current_epoch) # self.writer.add_scalar('MPA', MPA, self.current_epoch) # self.writer.add_scalar('MIoU', MIoU, self.current_epoch) # self.writer.add_scalar('FWIoU', FWIoU, self.current_epoch)
from utils import arg_parser from grid_map_generator import GridMapGenerator if __name__ == "__main__": args = arg_parser() generator = GridMapGenerator() generator.generate(args.src, args.scaler)
from data_loader import BSDSLoader from models import HED, convert_vgg, weights_init from functions import cross_entropy_loss # sigmoid_cross_entropy_loss from utils import Logger, Averagvalue, save_checkpoint, load_vgg16pretrain, arg_parser, tune_lrs from scipy.io import savemat root = '../..' args = arg_parser(dataset=join(root, 'HED-BSDS'), batch_size=1, lr=1e-6, momentum=0.9, weight_decay=2e-4, stepsize=3, gamma=0.1, start_epoch=0, maxepoch=10, itersize=10, print_freq=50, gpu='1', resume='', tmp=join('tmp', 'HED')) args.model_path = join(root, 'pretrained_models', 'vgg16.pth') os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID" # see issue #152 os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu THIS_DIR = abspath(dirname(__file__)) TMP_DIR = join(THIS_DIR, args.tmp) if not isdir(TMP_DIR):
""" # Library imports import time import pandas as pd import numpy as np # Custom imports import utils import plot import read_h5 as read import preprocessing as pp import neural_net as nn import kmeans as km args = utils.arg_parser() # Read data from h5 files into dataframe ############################################################################### t_start = time.time() df = read.h5_to_df('../../MillionSongSubset/data', args.size, args.initialize) t_extract = time.time() print('\nGot', len(df.index), 'songs in', round((t_extract - t_start), 2), 'seconds.') # Setup directory for preprocessing and model storage ############################################################################### path = utils.setup_model_dir() # Transform data into vectors for processing by neural network ###############################################################################