def get_models(args, BERT_PT_PATH, trained=False, path_model_bert=None, path_model=None): # some constants agg_ops = ['', 'MAX', 'MIN', 'COUNT', 'SUM', 'AVG'] cond_ops = ['=', '>', '<', 'OP'] # do not know why 'OP' required. Hence, print(f"Batch_size = {args.bS * args.accumulate_gradients}") print(f"Accumulate_gradients = {args.accumulate_gradients}") print(f"BERT parameters:") print(f"learning rate: {args.lr_bert}") print(f"Fine-tune BERT: {args.fine_tune}") # Get BERT model_bert, tokenizer, bert_config = get_bert(BERT_PT_PATH, args.bert_type, args.do_lower_case, args.my_pretrain_bert) args.iS = bert_config.hidden_size * args.num_target_layers # Seq-to-SQL input vector dimenstion # Get Seq-to-SQL n_cond_ops = len(cond_ops) n_agg_ops = len(agg_ops) print( f"Seq-to-SQL: the number of final BERT layers to be used: {args.num_target_layers}" ) print(f"Seq-to-SQL: the size of hidden dimension = {args.hS}") print(f"Seq-to-SQL: LSTM encoding layer size = {args.lS}") print(f"Seq-to-SQL: dropout rate = {args.dr}") print(f"Seq-to-SQL: learning rate = {args.lr}") model = Seq2SQL_v1(args.iS, args.hS, args.lS, args.dr, n_cond_ops, n_agg_ops) model = model.to(device) if trained: assert path_model_bert != None assert path_model != None if torch.cuda.is_available(): res = torch.load(path_model_bert) else: res = torch.load(path_model_bert, map_location='cpu') model_bert.load_state_dict(res['model_bert']) model_bert.to(device) if torch.cuda_is_available(): res = torch.load(path_model) else: res = torch.load(path_model, map_location='cpu') model.load_state_dict(res['model']) return model, model_bert, tokenizer, bert_config
def __init__(self, encoder: Encoder, decoder: DecoderPythonCRF, entries: EntriesProcessor,teacher_forcing_ratio = 0.5, learning_rate=0.01, max_input_length=40, max_output_length=20, device=None): self.encoder = encoder self.decoder = decoder self.entries = entries self.teacher_forcing_ratio = teacher_forcing_ratio self.encoder_optimizer = optim.Adam(encoder.parameters()) self.decoder_optimizer = optim.Adam(decoder.parameters()) self.max_input_length = max_input_length self.max_output_length = max_output_length if device is None: self.device = torch.device("cuda" if torch.cuda_is_available() else "cpu") else: self.device = device
def get_vgg(cuda=False): vgg = models.vgg19(pretrained=True) vgg_features = vgg.features """ We freeze the parameters because in style transfer, we only want to use the VGG19 model as a feature extractor, not to train it via backpropagation. Instead, backprop will aim to minimize the loss function that compares the content/style representations of the target image with the output image """ for param in vgg.parameters(): param.requires_grad = False if cuda: device = torch.device("cuda" if torch.cuda_is_available() else "cpu") vgg_features.to(device) return vgg_features
def get_models(config, BERT_PATH, trained=False, path_model_bert=None, path_model=None): # some constants agg_ops = ['', 'MAX', 'MIN', 'COUNT', 'SUM', 'AVG'] cond_ops = ['=', '>', '<', 'OP'] # do not know why 'OP' required. Hence, # Get BERT model_bert, tokenizer, bert_config = get_bert(BERT_PATH) input_size = bert_config.hidden_size * config[ "num_target_layers"] # Seq-to-SQL input vector dimenstion # Get Seq-to-SQL number_cond_ops = len(cond_ops) number_agg_ops = len(agg_ops) model = Seq2SQL_v1(input_size=input_size, hidden_size=100, num_layer=2, dropout=config["dropout"], number_cond_ops=number_cond_ops, number_agg_ops=number_agg_ops) model = model.to(device) if trained: assert path_model_bert != None assert path_model != None if torch.cuda.is_available(): res = torch.load(path_model_bert) else: res = torch.load(path_model_bert, map_location='cpu') model_bert.load_state_dict(res['model_bert']) model_bert.to(device) if torch.cuda_is_available(): res = torch.load(path_model) else: res = torch.load(path_model, map_location='cpu') model.load_state_dict(res['model']) return model, model_bert, tokenizer, bert_config
def __init__(self, actor_id, replay_buffer, parameter_server, config, epsilon, eval=False): self.actor_id = actor_id self.replay_buffer = replay_buffer self.parameter_server = parameter_server self.config = config self.epsilon = epsilon self.eval = eval self.device = torch.device("cpu") if config["eval_device"] == "gpu": if torch.cuda_is_available(): self.device = torch.device("cuda:0") self.observation_shape = config["observation_shape"] self.num_actions = config["num_actions"] self.multi_step_n = config.get("n_step", 1) self.q_update_freq = config.get("q_update_freq", 100) self.send_experience_freq = config.get("send_experience_freq", 100) self.q_net = get_q_network(config) if self.eval: self.q_net.eval() else: self.q_net.train() self.q_net.to(self.device) self.env = gym.make(config["env"]) self.local_buffer = [] self.continue_sampling = True self.cur_episodes = 0 self.cur_steps = 0
def __init__(self, config, replay_buffer, parameter_server): self.config = config self.replay_buffer = replay_buffer self.parameter_server = parameter_server self.target_network_update_interval = config.get( "target_network_update_interval", 32) self.device = torch.device("cpu") if config["eval_device"] == "gpu": if torch.cuda_is_available(): self.device = torch.device("cuda:0") self.q_net = get_q_network(config).train().to(self.device) self.target_q_net = copy.deepcopy(self.q_net).to(self.device) self.train_batch_size = config["train_batch_size"] self.total_collected_samples = 0 self.samples_since_last_update = 0 self.optimizer = optim.Adam(self.q_net.parameters(), lr=config["lr"]) self.loss = nn.MSELoss() self.send_weights() self.stopped = False
def main(argv): try: from torch.utils.tensorboard import SummaryWriter writer = SummaryWriter() except ImportError: writer = None torch.manual_seed(FLAGS.random_seed) np.random.seed(FLAGS.random_seed) if hasattr(torch, "cuda_is_available"): if torch.cuda_is_available(): torch.cuda.manual_seed(FLAGS.random_seed) torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True device = torch.device(FLAGS.device) kwargs = { "num_workers": 1, "pin_memory": True } if FLAGS.device == "cuda" else {} train_loader = torch.utils.data.DataLoader( torchvision.datasets.MNIST( root=".", train=True, download=True, transform=torchvision.transforms.Compose([ # torchvision.transforms. # RandomCrop(size=[28,28], padding=4) torchvision.transforms.ToTensor(), torchvision.transforms.Normalize((0.1307, ), (0.3081, )), ]), ), batch_size=FLAGS.batch_size, shuffle=True, **kwargs, ) test_loader = torch.utils.data.DataLoader( torchvision.datasets.MNIST( root=".", train=False, transform=torchvision.transforms.Compose([ torchvision.transforms.ToTensor(), torchvision.transforms.Normalize((0.1307, ), (0.3081, )), ]), ), batch_size=FLAGS.batch_size, **kwargs, ) label = os.environ.get("SLURM_JOB_ID", str(uuid.uuid4())) if FLAGS.prefix: path = f"runs/mnist/{FLAGS.prefix}/{label}" else: path = f"runs/mnist/{label}" os.makedirs(path, exist_ok=True) os.chdir(path) FLAGS.append_flags_into_file("flags.txt") input_features = 28 * 28 model = LIFConvNet( input_features, FLAGS.seq_length, model=FLAGS.model, device=device, only_first_spike=FLAGS.only_first_spike, ).to(device) if FLAGS.optimizer == "sgd": optimizer = torch.optim.SGD(model.parameters(), lr=FLAGS.learning_rate) elif FLAGS.optimizer == "adam": optimizer = torch.optim.Adam(model.parameters(), lr=FLAGS.learning_rate) if FLAGS.only_output: optimizer = torch.optim.Adam(model.out.parameters(), lr=FLAGS.learning_rate) training_losses = [] mean_losses = [] test_losses = [] accuracies = [] for epoch in range(FLAGS.epochs): training_loss, mean_loss = train(model, device, train_loader, optimizer, epoch, writer=writer) test_loss, accuracy = test(model, device, test_loader, epoch, writer=writer) training_losses += training_loss mean_losses.append(mean_loss) test_losses.append(test_loss) accuracies.append(accuracy) max_accuracy = np.max(np.array(accuracies)) if (epoch % FLAGS.model_save_interval == 0) and FLAGS.save_model: model_path = f"mnist-{epoch}.pt" save( model_path, model=model, optimizer=optimizer, epoch=epoch, is_best=accuracy > max_accuracy, ) np.save("training_losses.npy", np.array(training_losses)) np.save("mean_losses.npy", np.array(mean_losses)) np.save("test_losses.npy", np.array(test_losses)) np.save("accuracies.npy", np.array(accuracies)) model_path = "mnist-final.pt" save( model_path, epoch=epoch, model=model, optimizer=optimizer, is_best=accuracy > max_accuracy, ) if writer: writer.close()
from sklearn import preprocessing class M1(nn.Module): def __init__(self): super(Encode,self).__init__() self.conv1 = nn.Conv1d(3,3,10) self.conv2 = nn.Conv1d(3,3,10) def forward(self,x): x = x.permute(0,2,1) x = self.conv1(x) x = self.conv2(x) x = x.permute(0,2,1) return x device = 'cuda' if torch.cuda_is_available() else 'cpu' # defining the model model = M1() # defining the optimizer optimizer = optim.Adam(model.parameters()) # defining the loss function criterion = nn.L1Loss() # checking if GPU is available if torch.cuda.is_available(): model = model.cuda() criterion = criterion.cuda() epochs = 10 for i in range(epochs): arr = torch.empty((0,1,3)).to(device)
def main(): running_reward = 10 torch.manual_seed(FLAGS.random_seed) random.seed(FLAGS.random_seed) label = f"{FLAGS.policy}-{FLAGS.model}-{FLAGS.random_seed}" os.makedirs(f"runs/cartpole/{label}", exist_ok=True) os.chdir(f"runs/cartpole/{label}") FLAGS.append_flags_into_file("flags.txt") np.random.seed(FLAGS.random_seed) if hasattr(torch, "cuda_is_available"): if torch.cuda_is_available(): torch.cuda.manual_seed(FLAGS.random_seed) env = gym.make(FLAGS.environment) env.reset() env.seed(FLAGS.random_seed) if FLAGS.policy == "ann": policy = ANNPolicy() elif FLAGS.policy == "snn": policy = Policy() elif FLAGS.policy == "lsnn": policy = LSNNPolicy(device=FLAGS.device, model=FLAGS.model).to(FLAGS.device) optimizer = torch.optim.Adam(policy.parameters(), lr=FLAGS.learning_rate) running_rewards = [] episode_rewards = [] for e in range(FLAGS.episodes): state, ep_reward = env.reset(), 0 for t in range(1, 10000): # Don't infinite loop while learning action = select_action(state, policy, device=FLAGS.device) state, reward, done, _ = env.step(action) if FLAGS.render: env.render() policy.rewards.append(reward) ep_reward += reward if done: break running_reward = 0.05 * ep_reward + (1 - 0.05) * running_reward finish_episode(policy, optimizer) if e % FLAGS.log_interval == 0: logging.info( "Episode {}/{} \tLast reward: {:.2f}\tAverage reward: {:.2f}". format(e, FLAGS.episodes, ep_reward, running_reward)) episode_rewards.append(ep_reward) running_rewards.append(running_reward) if running_reward > env.spec.reward_threshold: logging.info("Solved! Running reward is now {} and " "the last episode runs to {} time steps!".format( running_reward, t)) break np.save("running_rewards.npy", np.array(running_rewards)) np.save("episode_rewards.npy", np.array(episode_rewards)) torch.save(optimizer.state_dict(), "optimizer.pt") torch.save(policy.state_dict(), "policy.pt")
def main(args): try: from torch.utils.tensorboard import SummaryWriter writer = SummaryWriter() except ImportError: writer = None torch.manual_seed(FLAGS.random_seed) np.random.seed(FLAGS.random_seed) if hasattr(torch, "cuda_is_available"): if torch.cuda_is_available(): torch.cuda.manual_seed(FLAGS.random_seed) torch.backends.cudnn.enabled = True torch.backends.cudnn.benchmark = True device = torch.device(FLAGS.device) constant_current_encoder = IFConstantCurrentEncoder( seq_length=FLAGS.seq_length, v_th=FLAGS.current_encoder_v_th) def polar_current_encoder(x): x_p, _ = constant_current_encoder(2 * torch.nn.functional.relu(x)) x_m, _ = constant_current_encoder(2 * torch.nn.functional.relu(-x)) return torch.cat((x_p, x_m), 1) def current_encoder(x): x, _ = constant_current_encoder(2 * x) return x def poisson_encoder(x): return poisson_train(x, seq_length=FLAGS.seq_length) def signed_poisson_encoder(x): return signed_poisson_train(x, seq_length=FLAGS.seq_length) def signed_current_encoder(x): z, _ = constant_current_encoder(torch.abs(x)) return torch.sign(x) * z num_channels = 4 if FLAGS.encoding == "poisson": encoder = poisson_encoder elif FLAGS.encoding == "constant": encoder = current_encoder elif FLAGS.encoding == "signed_poisson": encoder = signed_poisson_encoder elif FLAGS.encoding == "signed_constant": encoder = signed_current_encoder elif FLAGS.encoding == "constant_polar": encoder = polar_current_encoder num_channels = 2 * num_channels luminance_transforms = [ add_luminance, torchvision.transforms.Normalize((0.4914, 0.4822, 0.4465, 0.4816), (0.2023, 0.1994, 0.2010, 0.20013)), ] transform_train = torchvision.transforms.Compose([ torchvision.transforms.RandomCrop(32, padding=4), torchvision.transforms.RandomHorizontalFlip(), torchvision.transforms.ToTensor(), ] + luminance_transforms + [encoder]) transform_test = torchvision.transforms.Compose( [torchvision.transforms.ToTensor()] + luminance_transforms + [encoder]) kwargs = { "num_workers": 0, "pin_memory": True } if FLAGS.device == "cuda" else {} train_loader = torch.utils.data.DataLoader( torchvision.datasets.CIFAR10(root=".", train=True, download=True, transform=transform_train), batch_size=FLAGS.batch_size, shuffle=True, **kwargs, ) test_loader = torch.utils.data.DataLoader( torchvision.datasets.CIFAR10(root=".", train=False, transform=transform_test), batch_size=FLAGS.batch_size, **kwargs, ) label = os.environ.get("SLURM_JOB_ID", str(uuid.uuid4())) if not FLAGS.prefix: rundir = f"runs/cifar10/{label}" else: rundir = f"runs/cifar10/{FLAGS.prefix}/{label}" os.makedirs(rundir, exist_ok=True) os.chdir(rundir) FLAGS.append_flags_into_file("flags.txt") model = LIFConvNet( num_channels=num_channels, device=device, ).to(device) print(model) if device == "cuda": model = torch.nn.DataParallel(model).to(device) if FLAGS.optimizer == "sgd": optimizer = torch.optim.SGD( model.parameters(), lr=FLAGS.learning_rate, momentum=0.9, weight_decay=5e-4 * FLAGS.batch_size, nesterov=True, ) elif FLAGS.optimizer == "adam": optimizer = torch.optim.Adam(model.parameters(), lr=FLAGS.learning_rate) elif FLAGS.optimizer == "rms": optimizer = torch.optim.RMSprop(model.parameters(), lr=FLAGS.learning_rate) if FLAGS.only_output: optimizer = torch.optim.Adam(model.out.parameters(), lr=FLAGS.learning_rate) if FLAGS.resume: if os.path.isfile(FLAGS.resume): checkpoint = torch.load(FLAGS.resume) model.load_state_dict(checkpoint["state_dict"]) optimizer.load_state_dict(checkpoint["optimizer"]) if FLAGS.learning_rate_schedule: lr_scheduler = PiecewiseLinear(FLAGS.batch_size, [0, 5, FLAGS.epochs], [0, 0.4, 0]) else: lr_scheduler = None training_losses = [] mean_losses = [] test_losses = [] accuracies = [] start = datetime.datetime.now() for epoch in range(FLAGS.start_epoch, FLAGS.start_epoch + FLAGS.epochs): training_loss, mean_loss = train( model, device, train_loader, optimizer, epoch, lr_scheduler=lr_scheduler, writer=writer, ) test_loss, accuracy = test(model, device, test_loader, epoch, writer=writer) training_losses += training_loss mean_losses.append(mean_loss) test_losses.append(test_loss) accuracies.append(accuracy) if (epoch % FLAGS.model_save_interval == 0) and FLAGS.save_model: model_path = f"cifar10-{epoch}.pt" save(model_path, model, optimizer) stop = datetime.datetime.now() np.save("training_losses.npy", np.array(training_losses)) np.save("mean_losses.npy", np.array(mean_losses)) np.save("test_losses.npy", np.array(test_losses)) np.save("accuracies.npy", np.array(accuracies)) model_path = "cifar10-final.pt" save(model_path, model, optimizer) logging.info(f"output saved to {rundir}") logging.info(f"{start - stop}") if writer: writer.close()
from genrl import DQN from mario.supervised.adversarial import AdversariaTrainer from mario.base.wrapper import MarioEnv argument_parser = argparse.ArgumentParser( description="A script used to train agent adversarial on a dataset.") argument_parser.add_argument("-i", "--input-path", type=str, required=True) argument_parser.add_argument("-e", "--epochs", type=int, default=10) argument_parser.add_argument("--lr", type=float, default=1e-3) argument_parser.add_argument("-b", "--batch-size", type=int, default=64) argument_parser.add_argument("-l", "--length", type=int, default=None) argument_parser.add_argument("--enable-cuda", action="store_true") args = argument_parser.parse_args() if args.enable_cuda: if torch.cuda_is_available(): device = "cuda" else: device = "cpu" warnings.warn("cuda is ot available. Defaulting to cpu") else: device = "cpu" env = gym_super_mario_bros.make("SuperMarioBros-v0") env = JoypadSpace(env, SIMPLE_MOVEMENT) env = MarioEnv(env) agent = DQN("cnn", env, replay_size=100000, epsilon_decay=100000) trainer = AdversariaTrainer( agent=agent, env=env, dataset=args.input_path,
# ------------------------------------------ parser_train = subparsers.add_parser( "train", help="Command to train the model", ) parser_train.add_argument( "--epochs", help="Number of epochs", default=42, type=int) parser_train.add_argument( "--batch-size", help="Batch size", default=128, type=int) parser_train.set_defaults(func=train) # Evaluate parser # ------------------------------------------ parser_evaluate = subparsers.add_parser( "evaluate", help="Command to evaluate an existing model" ) parser_evaluate.set_defaults(func=evaluate) # Parse arguments # ------------------------------------------ args = parser.parse_args() use_cuda = args.cuda and torch.cuda_is_available() device = torch.device("cuda" if use_cuda else "cpu") args.func(args)
import torch import torch.nn as nn import torchvision.datasets as dsets import torchvision.transforms as transforms import torch.nn.functional as F import torch.optim as optim from torchsummary import summary batch_size = 100 total_epoch = 50 learning_rate = 0.01 device = torch.cuda_is_available() criterion = nn.CrossEntropyLoss() print(use_cuda) train_dataset = dsets.CIFAR10(root='./data', train=True, transform=transforms.ToTensor(), download=True) test_dataset = dsets.CIFAR10( root='./data', train=True, transform=transforms.ToTensor(), ) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True) test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size, shuffle=False)
def main(args): #device configuration if args.cpu != None: device = torch.device('cpu') elif args.gpu != None: if not torch.cuda_is_available(): print("GPU / cuda reported as unavailable to torch") exit(0) device = torch.device('cuda') else: device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') # Create model directory if not os.path.exists(args.model_save_dir): os.makedirs(args.model_save_dir) train_data = ld.get_data(labels_file=args.labels_file, root_dir=args.train_image_dir, mode="absolute") validation_data = ld.get_data(labels_file=args.labels_file, root_dir=args.validation_image_dir, mode="absolute") train_loader = DataLoader(dataset=train_data, batch_size=args.batch_size, shuffle=True) val_loader = DataLoader(dataset=validation_data, batch_size=args.validation_batch_size) # Build the models if args.num_layers != None and args.block_type != None: if args.block_type == "bottleneck": net = model.ResNet(model.Bottleneck, args.num_layers, dropout=args.dropout) else: net = model.ResNet(model.BasicBlock, args.num_layers, dropout=args.dropout) else: if args.resnet_model == 152: net = model.ResNet152(args.dropout) elif args.resnet_model == 101: net = model.ResNet101(args.dropout) elif args.resnet_model == 50: net = model.ResNet50(args.dropout) elif args.resnet_model == 34: net = model.ResNet34(args.dropout) else: net = model.ResNet101(args.dropout) #load the model to the appropriate device net = net.to(device) params = net.parameters() # Loss and optimizer criterion = nn.MSELoss() #best for regression if args.optim != None: if args.optim == "adadelta": optimizer = torch.optim.Adadelta(params, lr=args.learning_rate) if args.optim == "adagrad": optimizer = torch.optim.Adagrad(params, lr=args.learning_rate) if args.optim == "adam": optimizer = torch.optim.Adam(params, lr=args.learning_rate) if args.optim == "adamw": optimizer = torch.optim.AdamW(params, lr=args.learning_rate) if args.optim == "rmsprop": optimizer = torch.optim.RMSProp(params, lr=args.learning_rate) if args.optim == "sgd": optimizer = torch.optim.SGD(params, lr=args.learning_rate) else: optimizer = torch.optim.Adam(params, lr=args.learning_rate) val_acc_history = [] train_acc_history = [] failed_runs = 0 prev_loss = float("inf") for epoch in range(args.num_epochs): running_loss = 0.0 total_loss = 0.0 for i, (inputs, labels) in enumerate(train_loader, 0): net.train() #adjust to output image coordinates inputs, labels = inputs.to(device), labels.to(device) optimizer.zero_grad() outputs = net(inputs.float()) loss = criterion(outputs.float(), labels.float()) loss.backward() torch.nn.utils.clip_grad_norm_(net.parameters(), args.clipping_value) optimizer.step() running_loss += loss.item() total_loss += loss.item() if i % 2 == 0: #print every mini-batches print('[%d, %5d] loss: %.5f' % (epoch + 1, i + 1, running_loss / 2)) running_loss = 0.0 loss = 0.0 #compute validation loss at the end of the epoch for i, (inputs, labels) in enumerate(val_loader, 0): inputs, labels = inputs.to(device), labels.to(device) net.eval() with torch.no_grad(): outputs = net(inputs.float()) loss += criterion(outputs, labels.float()).item() print("------------------------------------------------------------") print("Epoch %5d" % (epoch + 1)) print("Training loss: {}, Avg Loss: {}".format( total_loss, total_loss / train_data.__len__())) print("Validation Loss: {}, Avg Loss: {}".format( loss, loss / validation_data.__len__())) print("------------------------------------------------------------") val_acc_history.append(loss) train_acc_history.append(total_loss) #save the model at the desired step if (epoch + 1) % args.save_step == 0: torch.save(net.state_dict(), args.model_save_dir + "resnet" + str(epoch + 1) + ".pt") ##stopping conditions if failed_runs > 5 and prev_loss < loss: break elif prev_loss < loss: failed_runs += 1 else: failed_runs = 0 prev_loss = loss #create a plot of the loss plt.title("Training vs Validation Accuracy") plt.xlabel("Training Epochs") plt.ylabel("Loss") plt.plot(range(1, len(val_acc_history) + 1), val_acc_history, label="Validation loss") plt.plot(range(1, len(train_acc_history) + 1), train_acc_history, label="Training loss") plt.xticks(np.arange(1, len(train_acc_history) + 1, 1.0)) plt.legend() plt.ylim((0, max([max(val_acc_history), max(train_acc_history)]))) if args.save_training_plot != None: plt.savefig(args.save_training_plot + "loss_plot.png") plt.show() print('Finished Training')