def main(): import configs from pytorch_utils import BaseOptions options = BaseOptions() options.parser = configs.get_args(options.parser) args = options.parse_args() sequence = KITTIObjectSequence(args, "/NAS/data/khantk/training/image_2") dataloader = torch.utils.data.DataLoader(sequence, batch_size=8, shuffle=True, num_workers=0) dataloader = sequence for i_batch, sample_batched in enumerate(dataloader): #print sequence[2]['next_image'].shape break
def main(): args = get_args() class_name = 'rotate' file_name = '00000020_NO_07.wav' signal_path = os.path.join(args.data_root, 'dataset', class_name, file_name) # # Read a sample from the dataset for testing # signal = load_data(class_name, file_name, signal_samples, args.data_root, args.signal_sr) signal, _ = torchaudio.load(signal_path) melkwargs = { 'n_mels': args.nfilt, 'n_fft': args.nfft, 'win_length': int(args.winlen * args.signal_sr), 'hop_length': int(args.winstep * args.signal_sr) } spectrogram = torchaudio.transforms.Spectrogram(n_fft=args.nfft, win_length=int(args.winlen * args.signal_sr), hop_length=int(args.winstep * args.signal_sr))(signal) mel_spectrogram = torchaudio.transforms.MelSpectrogram(sample_rate=args.signal_sr, n_fft=args.nfft, n_mels=args.nfilt, win_length=int(args.winlen * args.signal_sr), hop_length=int(args.winstep * args.signal_sr))(signal) mfcc = torchaudio.transforms.MFCC(sample_rate=args.signal_sr, n_mfcc=args.numcep, log_mels=True, melkwargs=melkwargs)(signal) num_frames = spectrogram.size()[2] plot_features(args, spectrogram, mel_spectrogram, mfcc, num_frames) history_path = os.path.join('..', 'assets', 'history.json') # Load the history file with open(history_path, mode='rb') as history_file: history = json.load(history_file) plot_history(args, history) plt.show()
acc_meter.reset() for idx, (images, labels) in enumerate(local_progress): with torch.no_grad(): feature = model(images.to(args.device)) preds = classifier(feature).argmax(dim=1) correct = (preds == labels.to(args.device)).sum().item() acc_meter.update(correct/preds.shape[0]) local_progress.set_postfix({'accuracy': acc_meter.avg}) global_progress.set_postfix({"epoch":epoch, 'accuracy':acc_meter.avg*100}) if __name__ == "__main__": main(args=get_args())
from pytorch_utils import BaseOptions import configs options = BaseOptions() options.parser = configs.get_args(options.parser) args = options.parse_args() if args.model.lower() == 'eventgan': from models.eventgan_trainer import EventGANTrainer trainer = EventGANTrainer(args) trainer.train() elif args.model.lower() == 'flow' or args.model.lower() == 'recons': import os import torch from models.flow_reconstruct_trainer import FlowReconstructTrainer trainer = FlowReconstructTrainer(args) trainer.train() checkpoint_filename = os.path.abspath( os.path.join(args.checkpoint_dir, '{}.pickle'.format(args.model.lower()))) torch.save(trainer.cycle_unet, checkpoint_filename) else: raise ValueError( "Model {} not supported, please select from {EventGAN, flow, recons}". format(args.model))
max_probs, targets_u = torch.max(pseudo_label1, dim=-1) mask = max_probs.ge(args.threshold_pl).float() Lu = (F.cross_entropy(ema_logit, targets_u, reduction='none') * mask).mean() loss = Lu optimizer.zero_grad() loss.backward() optimizer.step() # batch_loss.append(loss.item()) w_locals.append(copy.deepcopy(model_local.state_dict())) # loss_locals.append(sum(loss_local) / len(loss_local) ) del model_local gc.collect() del train_loader_unlabeled gc.collect() torch.cuda.empty_cache() w_glob = FedAvg(w_locals) model_glob.load_state_dict(w_glob) # loss_avg = sum(loss_locals) / len(loss_locals) if iter % 5 == 0: print('Round {:3d}, Acc {:.3f}'.format(iter, accuracy)) if __name__ == "__main__": args = get_args() main(device=args.device, args=args)
def train(): args = configs.get_args() use_cuda = args.use_cuda and torch.cuda.is_available() # prepare dataset dataset = libs.dataset.MyDataset(min_length=args.min_length) voc_size = dataset.get_voc_size() dataloader = DataLoader(dataset, 1, True, drop_last=False) # prepare model model = models.TopModuleCNN(voc_size, output_channel=args.output_channel) if use_cuda: model = model.cuda() # load pretrained if asked if args.resume: checkpoint_path = Checkpoint.get_certain_checkpoint( "./experiment/cnn_net", "best") resume_checkpoint = Checkpoint.load(checkpoint_path) model = resume_checkpoint.model optimizer = resume_checkpoint.optimizer resume_optim = optimizer.optimizer defaults = resume_optim.param_groups[0] defaults.pop('params', None) optimizer.optimizer = resume_optim.__class__(model.parameters(), **defaults) start_epoch = resume_checkpoint.epoch max_ans_acc = resume_checkpoint.max_ans_acc else: start_epoch = 1 max_ans_acc = 0 optimizer = NoamOpt( 512, 1, 2000, optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)) # define loss loss = nn.CrossEntropyLoss(weight=torch.tensor([1., 4.])) if use_cuda: loss = loss.cuda() # training for i in range(start_epoch, args.epochs): # test the model if args.resume: test_ans_acc = max_ans_acc else: test_ans_acc = test(DataLoader(dataset, 1, True, drop_last=False), model, i) print('For EPOCH {}, total f1: {:.2f}'.format(i, test_ans_acc)) # calculate loss j = 0 los1 = [] for _, data in enumerate(dataloader): j += 1 x = data['que'].long() y = data['ans'].long() res = data['res'].long() if use_cuda: x, y, res = x.cuda(), y.cuda(), res.cuda() res_pred = model(x, y) los1.append(loss(res_pred, res).unsqueeze(0)) # apply gradient if j % args.batch_size == 0: los1 = torch.cat(los1) los = los1.sum() model.zero_grad() los.backward() optimizer.step() los1 = [] print('EPOCH: {}, {} / {}====> LOSS: {:.2f}'.format( i, j // args.batch_size, dataloader.__len__() // args.batch_size, los.item() / args.batch_size)) # save checkpoint if test_ans_acc > max_ans_acc: max_ans_acc = test_ans_acc th_checkpoint = Checkpoint(model=model, optimizer=optimizer, epoch=i, max_ans_acc=max_ans_acc) th_checkpoint.save_according_name("./experiment/cnn_net", 'best')
# from tqdm import tqdm import logging import sys # from torch import optim import torch.nn as nn import torch # from networks import unet_vgg import configs, utils_ai import datasets if __name__ == '__main__': args = configs.get_args() # device = torch.device('cuda' if torch.cuda.is_available() ) device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') logging.info(f'Using deveice {device}') ### net = unet_vgg.UNet_VGG11() device_ids = list(map(int, args.device_ids.split(','))) model = nn.DataParallel(model, device_ids=device_ids).cuda() loss = Loss() if args.load: net.load_state_dict(torch.load(args.load, map_location=device)) logging.info(f'Model loaded from {args.load}') net.to(device=device) # faster convolutions, but more memory # cudnn.benchmark = True