def main(): global model_def global dataset global train args = argument_parser() config_module = importlib.import_module(args.config) configs = config_module.config model_def = importlib.import_module(args.model).model dataset = importlib.import_module(args.dataset).dataset train = importlib.import_module(args.trainer).train if 'algorithm' in configs.keys(): comet_config = parse_comet_config(configs) opt = Optimizer(comet_config, api_key=configs['API_KEY'], project_name=configs['project_name']) for exp in opt.get_experiments(): experiment = exp config = get_parameters(experiment, configs) train( **{ 'config': config, 'model_def': model_def, 'dataset': dataset, 'experiment': experiment }) else: if args.experiment: experiment = Experiment(api_key=configs['API_KEY'], project_name=configs['project_name'], workspace=configs['workspace']) else: experiment = None tried_configs = [] end = False while True: importlib.reload(config_module) configs = config_module.config possible_configs = get_configurations(configs) for config_idx, config in enumerate(possible_configs): if config_idx == len(possible_configs) - 1: end = True if config in tried_configs: continue else: tried_configs.append(config) train( **{ 'config': config, 'model_def': model_def, 'dataset': dataset, 'experiment': experiment }) break if end: break print("******************End of the training session****************")
def set_fitargs(self,fitargs,peculiar=[]): params = utils.get_parameters(fitargs) for key in peculiar: for prefix in [''] + utils.MINUIT_PREFIX + utils.OTHER_PREFIX: if prefix+key in fitargs: if prefix == 'latex_': fitargs['{}{}_{}'.format(prefix,key,self.parid)] = '{}^{{\\rm {}}}'.format(fitargs.pop(prefix+key),self.parid) else: fitargs['{}{}_{}'.format(prefix,key,self.parid)] = fitargs.pop(prefix+key) self.fitargs = fitargs
def Adv_training_data_CW(training_data, mean_cat, cov_cat, pi_cat, mean_grass, cov_grass, pi_grass, l=5, target_index=1, stride=8, alpha=0.0001): perturbed_data_k = training_data W_cat, w_cat, w_0_cat = get_parameters(mean_cat, cov_cat, pi_cat) W_grass, w_grass, w_0_grass = get_parameters(mean_grass, cov_grass, pi_grass) for i in range(300): current_grad = gradient_CW(patch_vec_k=perturbed_data_k, patch_vec_0=training_data, mean_cat=mean_cat, cov_cat=cov_cat, pi_cat=pi_cat, mean_grass=mean_grass, cov_grass=cov_grass, pi_grass=pi_grass, W_cat=W_cat, w_cat=w_cat, w_0_cat=w_0_cat, W_grass=W_grass, w_grass=w_grass, w_0_grass=w_0_grass, l=l, target_index=target_index) perturbed_data_k_1 = np.clip(perturbed_data_k - alpha * current_grad, 0, 1) change = np.linalg.norm((perturbed_data_k_1 - perturbed_data_k)) perturbed_data_k = perturbed_data_k_1 if change < 0.001 / (2850): break return perturbed_data_k_1
def init(self,path_data=None,path_covariance=None): if not hasattr(self,'parid'): self.parid = self.id if not self.sorted: self.sorted = pyspectrum.utils.sorted_parameters(utils.get_parameters(self.fitargs)) self._kwargs,self._amodel = {},[] self.set_model() if path_data is None: if path_covariance is None: self.logger.info('Using preloaded data {} and covariance {}.'.format(self.params['path_data'],self.params['path_covariance'])) else: self.set_data_covariance(path_covariance) self.logger.info('Using preloaded covariance {}.'.format(self.params['path_covariance'])) else: if path_covariance is not None: self.set_covariance(path_covariance) else: self.logger.info('Using preloaded covariance {}.'.format(self.params['path_covariance'])) self.set_data(path_data) #self.check_compatibility() if 'spectrum' in self.estimator: self.geometry.set_kout(kout={ell:self.xdata[ill] for ill,ell in enumerate(self.ells)}) else: self.geometry.set_sout(sout={ell:self.xdata[ill] for ill,ell in enumerate(self.ells)}) self.set_lkl()
def model(X_train, Y_train, user, userName, layers_dim, C = 4, lr = 0.1): L = len(layers_dim) parameters = get_parameters(layers_dim, userName, user, C) # global_cost = {} # for id in all_user: # global_cost[str(id)] = [] # Stochastic gradient descent X = X_train.reshape((2,1)) Y_oh = convert_to_oh(Y_train, C).reshape((C, 1)) caches, AL = forward_probagation(X, layers_dim, parameters) cost = cost_func(Y_oh, AL) grads = backward_probagation(Y_oh, caches, layers_dim) parameters = update_parameters(parameters, grads, layers_dim, lr) pck.dump(parameters, open("C:/Users/pevip/OneDrive/Documents/GitHub/JobSite/JobPosting/JobPosting/AI/RecommenderSystem/users/" + userName + "_profile.p", "wb")) pck.dump(C, open("C:/Users/pevip/OneDrive/Documents/GitHub/JobSite/JobPosting/JobPosting/AI/RecommenderSystem/prevLayer.p", "wb")) # global_cost[str(userID)].append(cost) # for id in all_user: # plt.plot(global_cost[str(id)]) # plt.show() return parameters
from generator import ER_generator, draw_anomalies from basic_test import basic_features from com_detection import community_detection from spectral_localisation import spectral_features from NetEMD import NetEMD_features from path_finder import path_features num_models = 20 num_nodes = 1000 num_basic_mc_samples = 500 num_references = 10 num_null_models = 60 ps = np.linspace(0.001, 0.05, 50) ws = np.linspace(0.0, 0.01, 11) candidate_parameters = get_parameters(num_nodes, ps, ws) num_cand_param = len(candidate_parameters) for model_id in range(num_models): p, w = candidate_parameters[np.random.choice(range(num_cand_param))] logging.info("Computing {}-th/{} model (p={:.3f}, w={:.3f})".format( model_id, num_models, p, w)) graph = ER_generator(n=num_nodes, p=p, seed=None) graph = draw_anomalies(graph, w=1 - w) logging.info("\n\nGenerating null models\n\n") _, references = generate_null_models(graph, num_models=num_references, min_size=20) null_samples_whole, null_samples = generate_null_models( graph, num_models=num_null_models, min_size=20) logging.info("\n\nGenerating NetEMD features\n\n")
def main(): args = get_args() args.world_size = args.gpus * args.nodes args.rank = args.gpus * args.nr + args.local_rank print("RANK: " + str(args.rank) + ", LOCAL RANK: " + str(args.local_rank)) # Log log_format = '[%(asctime)s] %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%d %I:%M:%S') t = time.time() local_time = time.localtime(t) if not os.path.exists('/home/admin/aihub/SinglePathOneShot/log'): os.mkdir('/home/admin/aihub/SinglePathOneShot/log') fh = logging.FileHandler( os.path.join( '/home/admin/aihub/SinglePathOneShot/log/train-{}{:02}{}'.format( local_time.tm_year % 2000, local_time.tm_mon, t))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) use_gpu = False if torch.cuda.is_available(): use_gpu = True assert os.path.exists(args.train_dir) train_dataset = datasets.ImageFolder( args.train_dir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomHorizontalFlip(0.5), ToBGRTensor(), ])) train_sampler = torch.utils.data.distributed.DistributedSampler( train_dataset, num_replicas=args.world_size, rank=args.rank) train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=args.batch_size, shuffle=False, num_workers=32, pin_memory=True, sampler=train_sampler) train_dataprovider = DataIterator(train_loader) assert os.path.exists(args.val_dir) val_loader = torch.utils.data.DataLoader(datasets.ImageFolder( args.val_dir, transforms.Compose([ OpencvResize(256), transforms.CenterCrop(224), ToBGRTensor(), ])), batch_size=200, shuffle=False, num_workers=32, pin_memory=use_gpu) val_dataprovider = DataIterator(val_loader) print('load data successfully') dist.init_process_group(backend='nccl', init_method='env://', world_size=args.world_size, rank=args.local_rank) # dist.init_process_group(backend='nccl', init_method='tcp://'+args.ip+':'+str(args.port), world_size=args.world_size, rank=args.rank) # dist.init_process_group(backend='nccl', init_method="file:///mnt/nas1/share_file", world_size=args.world_size, rank=args.rank) torch.cuda.set_device(args.local_rank) channels_scales = (1.0, ) * 20 model = ShuffleNetV2_OneShot(architecture=list(args.arch), channels_scales=channels_scales) device = torch.device(args.local_rank) model = model.cuda(args.local_rank) optimizer = torch.optim.SGD(get_parameters(model), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) criterion_smooth = CrossEntropyLabelSmooth(1000, 0.1) scheduler = torch.optim.lr_scheduler.LambdaLR( optimizer, lambda step: (1.0 - step / args.total_iters) if step <= args.total_iters else 0, last_epoch=-1) model = torch.nn.parallel.DistributedDataParallel( model, device_ids=[args.local_rank], find_unused_parameters=False) #,output_device=args.local_rank) # , loss_function = criterion_smooth.cuda() all_iters = 0 args.optimizer = optimizer args.loss_function = loss_function args.scheduler = scheduler args.train_dataprovider = train_dataprovider args.val_dataprovider = val_dataprovider if args.eval: if args.eval_resume is not None: checkpoint = torch.load(args.eval_resume, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint, strict=True) validate(model, device, args, all_iters=all_iters) exit(0) validate(model, device, args, all_iters=all_iters) while all_iters < args.total_iters: all_iters = train(model, device, args, val_interval=args.val_interval, bn_process=False, all_iters=all_iters) validate(model, device, args, all_iters=all_iters) all_iters = train(model, device, args, val_interval=int(1280000 / args.val_batch_size), bn_process=True, all_iters=all_iters) validate(model, device, args, all_iters=all_iters)
def parameters(self): return utils.get_parameters(self.fitargs)
def main(): args = get_args() # archLoader arch_loader = ArchLoader(args.path) # Log log_format = '[%(asctime)s] %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%d %I:%M:%S') t = time.time() local_time = time.localtime(t) if not os.path.exists('./log'): os.mkdir('./log') fh = logging.FileHandler( os.path.join('log/train-{}{:02}{}'.format(local_time.tm_year % 2000, local_time.tm_mon, t))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) use_gpu = False if torch.cuda.is_available(): use_gpu = True train_dataset, val_dataset = get_dataset('cifar100') train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=16, pin_memory=True) # train_dataprovider = DataIterator(train_loader) val_loader = torch.utils.data.DataLoader(val_dataset, batch_size=200, shuffle=False, num_workers=12, pin_memory=True) # val_dataprovider = DataIterator(val_loader) print('load data successfully') model = mutableResNet20() print('load model successfully') optimizer = torch.optim.SGD(get_parameters(model), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) criterion_smooth = CrossEntropyLabelSmooth(1000, 0.1) if use_gpu: model = nn.DataParallel(model) loss_function = criterion_smooth.cuda() device = torch.device("cuda") else: loss_function = criterion_smooth device = torch.device("cpu") scheduler = torch.optim.lr_scheduler.LambdaLR( optimizer, lambda step: (1.0 - step / args.total_iters) if step <= args.total_iters else 0, last_epoch=-1) model = model.to(device) # dp_model = torch.nn.parallel.DistributedDataParallel(model) all_iters = 0 if args.auto_continue: # 自动进行?? lastest_model, iters = get_lastest_model() if lastest_model is not None: all_iters = iters checkpoint = torch.load(lastest_model, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint['state_dict'], strict=True) print('load from checkpoint') for i in range(iters): scheduler.step() # 参数设置 args.optimizer = optimizer args.loss_function = loss_function args.scheduler = scheduler args.train_loader = train_loader args.val_loader = val_loader # args.train_dataprovider = train_dataprovider # args.val_dataprovider = val_dataprovider if args.eval: if args.eval_resume is not None: checkpoint = torch.load(args.eval_resume, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint, strict=True) validate(model, device, args, all_iters=all_iters, arch_loader=arch_loader) exit(0) while all_iters < args.total_iters: all_iters = train(model, device, args, val_interval=args.val_interval, bn_process=False, all_iters=all_iters, arch_loader=arch_loader, arch_batch=args.arch_batch)
lats.append(chan.latitude) lons.append(chan.longitude) sc = ax.scatter(lons, lats, 200., color='C1', edgecolor='k', marker="v", transform=ccrs.PlateCarree(), label='IW Stations') mlon = np.mean(lons) mlat = np.mean(lats) paramdic = utils.get_parameters('P') cat = client.get_events(starttime=stime, endtime=etime, minmagnitude=paramdic['min_mag'], maxmagnitude=paramdic['max_mag'], latitude=mlat, longitude=mlon, maxradius=paramdic['max_radius'], minradius=paramdic['min_radius']) evelats = [] evelons = [] for eve in cat: evelats.append(eve.origins[0].latitude) evelons.append(eve.origins[0].longitude) print(evelons)
if (__name__ == "__main__" ): log('v%s started' % __settings__.getAddonInfo("version"), xbmc.LOGNOTICE) HANDLE = int(sys.argv[1]) if not (__settings__.getSetting("firstrun")): __settings__.openSettings() if utils.pass_setup_test(SABNZBD.setup_streaming(), __settings__.getSetting("sabnzbd_incomplete")): __settings__.setSetting("firstrun", '1') else: if (not sys.argv[2]): add_posts({'title':'Incomplete'}, '', MODE_INCOMPLETE) add_posts({'title':'Browse local NZB\'s'}, '', MODE_LOCAL, '', '') xbmcplugin.setContent(HANDLE, 'movies') xbmcplugin.endOfDirectory(HANDLE, succeeded=True, cacheToDisc=True) else: params = utils.get_parameters(sys.argv[2]) get = params.get if get("mode")== MODE_PLAY: is_home, sab_nzo_id = is_nzb_home(params) if is_home: nzbname = utils.unquote_plus(get("nzbname")) pre_play(nzbname, nzo=sab_nzo_id) if get("mode")== MODE_LIST_PLAY or get("mode")== MODE_AUTO_PLAY: play_video(params) if get("mode")== MODE_DELETE: delete(params) if get("mode")== MODE_DOWNLOAD: download(params) if get("mode")== MODE_REPAIR: repair(params) if get("mode")== MODE_INCOMPLETE:
def main(): args = get_args() # Log log_format = '[%(asctime)s] %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%d %I:%M:%S') t = time.time() local_time = time.localtime(t) if not os.path.exists('./log'): os.mkdir('./log') fh = logging.FileHandler( os.path.join('log/train-{}{:02}{}'.format(local_time.tm_year % 2000, local_time.tm_mon, t))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) use_gpu = False if torch.cuda.is_available(): use_gpu = True if args.cifar10 == False: assert os.path.exists(args.train_dir) train_dataset = datasets.ImageFolder( args.train_dir, transforms.Compose([ transforms.RandomResizedCrop(224), transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomHorizontalFlip(0.5), ToBGRTensor(), ])) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=1, pin_memory=use_gpu) train_dataprovider = DataIterator(train_loader) assert os.path.exists(args.val_dir) val_loader = torch.utils.data.DataLoader(datasets.ImageFolder( args.val_dir, transforms.Compose([ OpencvResize(256), transforms.CenterCrop(224), ToBGRTensor(), ])), batch_size=200, shuffle=False, num_workers=1, pin_memory=use_gpu) val_dataprovider = DataIterator(val_loader) print('load imagenet data successfully') else: train_transform, valid_transform = data_transforms(args) trainset = torchvision.datasets.CIFAR10(root=os.path.join( args.data_dir, 'cifar'), train=True, download=True, transform=train_transform) train_loader = torch.utils.data.DataLoader(trainset, batch_size=args.batch_size, shuffle=True, pin_memory=True, num_workers=8) train_dataprovider = DataIterator(train_loader) valset = torchvision.datasets.CIFAR10(root=os.path.join( args.data_dir, 'cifar'), train=False, download=True, transform=valid_transform) val_loader = torch.utils.data.DataLoader(valset, batch_size=args.batch_size, shuffle=False, pin_memory=True, num_workers=8) val_dataprovider = DataIterator(val_loader) print('load cifar10 data successfully') model = ShuffleNetV2_OneShot() optimizer = torch.optim.SGD(get_parameters(model), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) criterion_smooth = CrossEntropyLabelSmooth(1000, 0.1) if use_gpu: model = nn.DataParallel(model) loss_function = criterion_smooth.cuda() device = torch.device("cuda") else: loss_function = criterion_smooth device = torch.device("cpu") scheduler = torch.optim.lr_scheduler.LambdaLR( optimizer, lambda step: (1.0 - step / args.total_iters) if step <= args.total_iters else 0, last_epoch=-1) model = model.to(device) all_iters = 0 if args.auto_continue: lastest_model, iters = get_lastest_model() if lastest_model is not None: all_iters = iters checkpoint = torch.load(lastest_model, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint['state_dict'], strict=True) print('load from checkpoint') for i in range(iters): scheduler.step() args.optimizer = optimizer args.loss_function = loss_function args.scheduler = scheduler args.train_dataprovider = train_dataprovider args.val_dataprovider = val_dataprovider if args.eval: if args.eval_resume is not None: checkpoint = torch.load(args.eval_resume, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint, strict=True) validate(model, device, args, all_iters=all_iters) exit(0) while all_iters < args.total_iters: all_iters = train(model, device, args, val_interval=args.val_interval, bn_process=False, all_iters=all_iters)
def CW_attack_fast(img_0, mean_cat_attack, cov_cat_attack, pi_cat_attack, mean_grass_attack, cov_grass_attack, pi_grass_attack, mean_cat_defense, cov_cat_defense, pi_cat_defense, mean_grass_defense, cov_grass_defense, pi_grass_defense, original_img, truth, l=5, target_index=1, stride=8, alpha=0.0001, display_iter=300, title='', path='./Outputs', preprocessing=[None, None], attack_type='blackbox'): iter_num = 0 parallel_img_0 = parallel(img_0, stride=stride) img_k = img_0 W_cat, w_cat, w_0_cat = get_parameters(mean_cat_attack, cov_cat_attack, pi_cat_attack) W_grass, w_grass, w_0_grass = get_parameters(mean_grass_attack, cov_grass_attack, pi_grass_attack) while iter_num < 300: iter_num += 1 parallel_img_k = parallel(img_k, stride=stride) if attack_type == 'whitebox' and preprocessing[0] != None: parallel_img_k = preprocessing[0].forward(parallel_img_k) parallel_img_0 = preprocessing[0].forward(parallel_img_0) current_grad = gradient_CW(patch_vec_k=parallel_img_k, patch_vec_0=parallel_img_0, mean_cat=mean_cat_attack, cov_cat=cov_cat_attack, pi_cat=pi_cat_attack, mean_grass=mean_grass_attack, cov_grass=cov_grass_attack, pi_grass=pi_grass_attack, W_cat=W_cat, w_cat=w_cat, w_0_cat=w_0_cat, W_grass=W_grass, w_grass=w_grass, w_0_grass=w_0_grass, l=l, target_index=target_index) grad = unparallel_grad(current_grad, img_0, stride=stride) img_k_1 = np.clip(img_k - alpha * grad, 0, 1) change = np.linalg.norm((img_k_1 - img_k)) img_k = img_k_1 if (iter_num) % display_iter == 0: print("\n") display_image(img_perturbed=img_k_1, mean_cat=mean_cat_defense, cov_cat=cov_cat_defense, pi_cat=pi_cat_defense, mean_grass=mean_grass_defense, cov_grass=cov_grass_defense, pi_grass=pi_grass_defense, original_img=original_img, truth=truth, title=title + 'iter_' + str(iter_num), stride=stride, preprocessing=preprocessing[1], path=path) print(' Change:{}'.format(change)) if change < 0.001 and stride == 8: print("\n\nMax Iteration:" + str(iter_num)) break elif change < 0.01 and stride == 1: print("\n\nMax Iteration:" + str(iter_num)) break return img_k_1
tree = spatial.cKDTree(matrix) return tree.query(vector) df = utils.create_finger_print_data_frame(cs.FINGERPRINT_FILE, cs.PARAMETER_FILE, cs.PARAMETER_KEY, cs.CACHE_FILE, force=True) import sklearn from sklearn.neighbors import KNeighborsRegressor from sklearn.model_selection import train_test_split parameters = utils.get_parameters() y = df.iloc[:, -len(parameters):] x = df.iloc[:, :-len(parameters)] real = x.values.real imag = x.values.imag x = numpy.concatenate((real, imag), axis=1) x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2) knn = KNeighborsRegressor() knn.fit(x_train, y_train) predicted = knn.predict(x_test)
def main(): args = get_args() # Log log_format = '[%(asctime)s] %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%d %I:%M:%S') t = time.time() local_time = time.localtime(t) if not os.path.exists('./log'): os.mkdir('./log') fh = logging.FileHandler(os.path.join('log/train-{}{:02}{}'.format(local_time.tm_year % 2000, local_time.tm_mon, t))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) use_gpu = False if torch.cuda.is_available(): use_gpu = True assert os.path.exists(args.train_dir) train_dataset = datasets.ImageFolder( args.train_dir, transforms.Compose([ transforms.RandomResizedCrop(args.im_size), transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomHorizontalFlip(0.5), ToBGRTensor(), ]) ) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=8, pin_memory=use_gpu) train_dataprovider = DataIterator(train_loader) assert os.path.exists(args.val_dir) val_loader = torch.utils.data.DataLoader( datasets.ImageFolder(args.val_dir, transforms.Compose([ transforms.Resize(256), transforms.CenterCrop(args.im_size), ToBGRTensor(), ])), batch_size=200, shuffle=False, num_workers=8, pin_memory=use_gpu ) val_dataprovider = DataIterator(val_loader) print('load data successfully') arch_path='arch.pkl' if os.path.exists(arch_path): with open(arch_path,'rb') as f: architecture=pickle.load(f) else: raise NotImplementedError channels_scales = (1.0,)*20 model = ShuffleNetV2_OneShot(architecture=architecture, channels_scales=channels_scales, n_class=args.num_classes, input_size=args.im_size) print('flops:',get_flops(model)) optimizer = torch.optim.SGD(get_parameters(model), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) criterion_smooth = CrossEntropyLabelSmooth(args.num_classes, 0.1) if use_gpu: # model = nn.DataParallel(model) loss_function = criterion_smooth.cuda() device = torch.device("cuda") else: loss_function = criterion_smooth device = torch.device("cpu") scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lambda step : (1.0-step/args.total_iters) if step <= args.total_iters else 0, last_epoch=-1) # model = model.to(device) model = model.cuda() all_iters = 0 if args.auto_continue: lastest_model, iters = get_lastest_model() if lastest_model is not None: all_iters = iters checkpoint = torch.load(lastest_model, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint['state_dict'], strict=True) print('load from checkpoint') for i in range(iters): scheduler.step() args.optimizer = optimizer args.loss_function = loss_function args.scheduler = scheduler args.train_dataprovider = train_dataprovider args.val_dataprovider = val_dataprovider if args.eval: if args.eval_resume is not None: checkpoint = torch.load(args.eval_resume, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint, strict=True) validate(model, device, args, all_iters=all_iters) exit(0) t = time.time() while all_iters < args.total_iters: all_iters = train(model, device, args, val_interval=args.val_interval, bn_process=False, all_iters=all_iters) validate(model, device, args, all_iters=all_iters) # all_iters = train(model, device, args, val_interval=int(1280000/args.batch_size), bn_process=True, all_iters=all_iters) validate(model, device, args, all_iters=all_iters) save_checkpoint({'state_dict': model.state_dict(),}, args.total_iters, tag='bnps-') print("Finished {} iters in {:.3f} seconds".format(all_iters, time.time()-t))
def main(): args = get_args() num_gpus = torch.cuda.device_count() args.gpu = args.local_rank % num_gpus torch.cuda.set_device(args.gpu) torch.distributed.init_process_group(backend='nccl', init_method='env://') args.world_size = torch.distributed.get_world_size() args.batch_size = args.batch_size // args.world_size # archLoader arch_loader = ArchLoader(args.path) # Log log_format = '[%(asctime)s] %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%m-%d %I:%M:%S') t = time.time() local_time = time.localtime(t) if not os.path.exists('./log'): os.mkdir('./log') fh = logging.FileHandler( os.path.join('log/train-{}-{:02}-{:02}-{:.3f}'.format( local_time.tm_year % 2000, local_time.tm_mon, local_time.tm_mday, t))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) use_gpu = False if torch.cuda.is_available(): use_gpu = True train_loader = get_train_loader(args.batch_size, args.local_rank, args.num_workers, args.total_iters) val_loader = get_val_loader(args.batch_size, args.num_workers) model = mutableResNet20() logging.info('load model successfully') optimizer = torch.optim.SGD(get_parameters(model), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) criterion_smooth = CrossEntropyLabelSmooth(1000, 0.1) if use_gpu: # model = nn.DataParallel(model) model = model.cuda(args.gpu) model = nn.parallel.DistributedDataParallel( model, device_ids=[args.local_rank], output_device=args.local_rank, find_unused_parameters=True) loss_function = criterion_smooth.cuda() else: loss_function = criterion_smooth scheduler = CosineAnnealingWarmRestarts(optimizer, T_0=5) all_iters = 0 if args.auto_continue: # 自动进行?? lastest_model, iters = get_lastest_model() if lastest_model is not None: all_iters = iters checkpoint = torch.load(lastest_model, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint['state_dict'], strict=True) logging.info('load from checkpoint') for i in range(iters): scheduler.step() # 参数设置 args.optimizer = optimizer args.loss_function = loss_function args.scheduler = scheduler args.train_loader = train_loader args.val_loader = val_loader if args.eval: if args.eval_resume is not None: checkpoint = torch.load(args.eval_resume, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint, strict=True) validate(model, args, all_iters=all_iters, arch_loader=arch_loader) exit(0) # warmup weights if args.warmup > 0: logging.info("begin warmup weights") while all_iters < args.warmup: all_iters = train_supernet(model, args, bn_process=False, all_iters=all_iters) validate(model, args, all_iters=all_iters, arch_loader=arch_loader) while all_iters < args.total_iters: logging.info("=" * 50) all_iters = train_subnet(model, args, bn_process=False, all_iters=all_iters, arch_loader=arch_loader) if all_iters % 200 == 0 and args.local_rank == 0: logging.info("validate iter {}".format(all_iters)) validate(model, args, all_iters=all_iters, arch_loader=arch_loader)
def main(): args = get_args() # Log log_format = '[%(asctime)s] %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%d %I:%M:%S') t = time.time() local_time = time.localtime(t) if not os.path.exists('./log'): os.mkdir('./log') fh = logging.FileHandler( os.path.join('log/train-{}{:02}{}'.format(local_time.tm_year % 2000, local_time.tm_mon, t))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) use_gpu = False if torch.cuda.is_available(): use_gpu = True assert os.path.exists(args.train_dir) train_dataset = datasets.ImageFolder( args.train_dir, transforms.Compose([ transforms.RandomResizedCrop(96), transforms.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.4), transforms.RandomHorizontalFlip(0.5), ToBGRTensor(), ])) train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=4, pin_memory=use_gpu) train_dataprovider = DataIterator(train_loader) assert os.path.exists(args.val_dir) val_loader = torch.utils.data.DataLoader( datasets.ImageFolder( args.val_dir, transforms.Compose([ OpencvResize(96), # transforms.CenterCrop(96), ToBGRTensor(), ])), batch_size=200, shuffle=False, num_workers=4, pin_memory=use_gpu) val_dataprovider = DataIterator(val_loader) arch_path = 'cl400.p' if os.path.exists(arch_path): with open(arch_path, 'rb') as f: architectures = pickle.load(f) else: raise NotImplementedError channels_scales = (1.0, ) * 20 cands = {} splits = [(i, 10 + i) for i in range(0, 400, 10)] architectures = np.array(architectures) architectures = architectures[ splits[args.split_num][0]:splits[args.split_num][1]] print(len(architectures)) logging.info("Training and Validating arch: " + str(splits[args.split_num])) for architecture in architectures: architecture = tuple(architecture.tolist()) model = ShuffleNetV2_OneShot(architecture=architecture, channels_scales=channels_scales, n_class=10, input_size=96) print('flops:', get_flops(model)) optimizer = torch.optim.SGD(get_parameters(model), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) criterion_smooth = CrossEntropyLabelSmooth(1000, 0.1) if use_gpu: model = nn.DataParallel(model) loss_function = criterion_smooth.cuda() device = torch.device("cuda") else: loss_function = criterion_smooth device = torch.device("cpu") scheduler = torch.optim.lr_scheduler.LambdaLR( optimizer, lambda step: (1.0 - step / args.total_iters) if step <= args.total_iters else 0, last_epoch=-1) model = model.to(device) all_iters = 0 if args.auto_continue: lastest_model, iters = get_lastest_model() if lastest_model is not None: all_iters = iters checkpoint = torch.load( lastest_model, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint['state_dict'], strict=True) print('load from checkpoint') for i in range(iters): scheduler.step() args.optimizer = optimizer args.loss_function = loss_function args.scheduler = scheduler args.train_dataprovider = train_dataprovider args.val_dataprovider = val_dataprovider # print("BEGIN VALDATE: ", args.eval, args.eval_resume) if args.eval: if args.eval_resume is not None: checkpoint = torch.load( args.eval_resume, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint, strict=True) validate(model, device, args, all_iters=all_iters) exit(0) # t1,t5 = validate(model, device, args, all_iters=all_iters) # print("VALDATE: ", t1, " ", t5) while all_iters < args.total_iters: all_iters = train(model, device, args, val_interval=args.val_interval, bn_process=False, all_iters=all_iters) validate(model, device, args, all_iters=all_iters) all_iters = train(model, device, args, val_interval=int(1280000 / args.batch_size), bn_process=True, all_iters=all_iters) top1, top5 = validate(model, device, args, all_iters=all_iters) save_checkpoint({ 'state_dict': model.state_dict(), }, args.total_iters, tag='bnps-') cands[architecture] = [top1, top5] pickle.dump( cands, open("from_scratch_split_{}.pkl".format(args.split_num), 'wb'))
import sys import numpy as np import csv import matplotlib.pyplot as plt import pickle as pck from utils import get_parameters, sigmoid, sigmoid_backward, softmax, softmax_backward, convert_to_oh, convert_dictionary_to_vector, convert_vector_to_dictionary, initialize_parameters, add_parameters, subtract_parameters from Train import model, predict if __name__ == "__main__": n_y = pck.load( open( r"C:\Users\pevip\OneDrive\Documents\GitHub\JobSite\JobPosting\JobPosting\AI\RecommenderSystem\prevlayer.p", "rb")) n_y = int(n_y) layers_dim = [2, 6, 10, n_y] user = int(sys.argv[1]) prev1 = int(sys.argv[2]) prev2 = int(sys.argv[3]) userName = sys.argv[4] X = np.array([prev1, prev2], dtype=np.int).reshape((2, 1)) parameters = get_parameters(layers_dim, userName, user, C=n_y) Y = predict(X, user, parameters, layers_dim) print(Y)
def main(): parser = argparse.ArgumentParser( "Variational autoencoders for collaborative filtering") parser.add_argument('cmd', type=str, choices=['train'], help='train') parser.add_argument('--arch_type', type=str, default='MultiVAE', help='architecture', choices=['MultiVAE', 'MultiDAE']) parser.add_argument('--dataset_name', type=str, default='ml-20m', help='camera model type', choices=['ml-20m', 'lastfm-360k']) parser.add_argument('--processed_dir', type=str, default='O:/dataset/vae_cf/data/ml-20m/pro_sg', help='dataset directory') parser.add_argument('--n_items', type=int, default=1, help='n items') parser.add_argument( '--conditioned_on', type=str, default=None, help= 'conditioned on user profile (g: gender, a: age, c: country) for Last.fm' ) parser.add_argument('--checkpoint_dir', type=str, default='./checkpoint/', help='checkpoints directory') parser.add_argument('--checkpoint_freq', type=int, default=1, help='checkpoint save frequency') parser.add_argument('--valid_freq', type=int, default=1, help='validation frequency in training') parser.add_argument( '-c', '--config', type=int, default=1, choices=configurations.keys(), help='the number of settings and hyperparameters used in training') parser.add_argument('--start_step', dest='start_step', type=int, default=0, help='start step') parser.add_argument('--total_steps', dest='total_steps', type=int, default=int(3e5), help='Total number of steps') parser.add_argument('--batch_size', type=int, default=1, help='batch size') parser.add_argument('--train_batch_size', type=int, default=1, help='batch size') parser.add_argument('--valid_batch_size', type=int, default=1, help='batch size in validation') parser.add_argument('--test_batch_size', type=int, default=1, help='batch size in test') parser.add_argument('--print_freq', type=int, default=1, help='log print frequency') parser.add_argument('--upper_train', type=int, default=-1, help='max of train images(for debug)') parser.add_argument('--upper_valid', type=int, default=-1, help='max of valid images(for debug)') parser.add_argument('--upper_test', type=int, default=-1, help='max of test images(for debug)') parser.add_argument( '--total_anneal_steps', type=int, default=0, help='the total number of gradient updates for annealing') parser.add_argument('--anneal_cap', type=float, default=0.2, help='largest annealing parameter') parser.add_argument('--dropout_p', dest='dropout_p', type=float, default=0.5, help='dropout rate') parser.add_argument('--gpu', type=int, default=0, help='GPU id') parser.add_argument('-j', '--workers', default=4, type=int, metavar='N', help='number of data loading workers (default: 4)') args = parser.parse_args() if args.cmd == 'train': os.makedirs(args.checkpoint_dir, exist_ok=True) cfg = configurations[args.config] print(args) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu) cuda = torch.cuda.is_available() if cuda: print("torch.backends.cudnn.version: {}".format( torch.backends.cudnn.version())) torch.manual_seed(98765) if cuda: torch.cuda.manual_seed(98765) # # 1. data loader kwargs = {'num_workers': args.workers, 'pin_memory': True} if cuda else {} root = args.processed_dir DS = dataset.MovieLensDataset if args.dataset_name == 'ml-20m' else dataset.LastfmDataset if args.cmd == 'train': dt = DS(root, 'data_csr.pkl', split='train', upper=args.upper_train, conditioned_on=args.conditioned_on) train_loader = torch.utils.data.DataLoader( dt, batch_size=args.train_batch_size, shuffle=True, **kwargs) dt = DS(root, 'data_csr.pkl', split='valid', upper=args.upper_valid, conditioned_on=args.conditioned_on) valid_loader = torch.utils.data.DataLoader( dt, batch_size=args.valid_batch_size, shuffle=False, **kwargs) dt = DS(root, 'data_csr.pkl', split='test', upper=args.upper_test, conditioned_on=args.conditioned_on) test_loader = torch.utils.data.DataLoader( dt, batch_size=args.test_batch_size, shuffle=False, **kwargs) # 2. model n_conditioned = 0 if args.conditioned_on: # used for conditional VAE if 'g' in args.conditioned_on: n_conditioned += 3 if 'a' in args.conditioned_on: n_conditioned += 10 if 'c' in args.conditioned_on: n_conditioned += 17 if 'MultiVAE' in args.arch_type: model = MultiVAE(dropout_p=args.dropout_p, weight_decay=0.0, cuda2=cuda, q_dims=[args.n_items, 600, 200], p_dims=[200, 600, args.n_items], n_conditioned=n_conditioned) if 'MultiDAE' in args.arch_type: model = MultiDAE(dropout_p=args.dropout_p, weight_decay=0.01 / args.train_batch_size, cuda2=cuda) print(model) start_epoch = 0 start_step = 0 if cuda: model = model.cuda() # 3. optimizer if args.cmd == 'train': optim = torch.optim.Adam( [ { 'params': list(utils.get_parameters(model, bias=False)), 'weight_decay': 0.0 }, { 'params': list(utils.get_parameters(model, bias=True)), 'weight_decay': 0.0 }, ], lr=cfg['lr'], ) # lr_policy: step last_epoch = -1 lr_scheduler = torch.optim.lr_scheduler.MultiStepLR( optim, milestones=[100, 150], gamma=cfg['gamma'], last_epoch=last_epoch) if args.cmd == 'train': trainer = Trainer( cmd=args.cmd, cuda=cuda, model=model, optim=optim, lr_scheduler=lr_scheduler, train_loader=train_loader, valid_loader=valid_loader, test_loader=test_loader, start_step=start_step, total_steps=args.total_steps, interval_validate=args.valid_freq, checkpoint_dir=args.checkpoint_dir, print_freq=args.print_freq, checkpoint_freq=args.checkpoint_freq, total_anneal_steps=args.total_anneal_steps, anneal_cap=args.anneal_cap, ) trainer.train()
def CW_attack(img_0, mean_cat, cov_cat, pi_cat, mean_grass, cov_grass, pi_grass, original_img, truth, l=5, target_index=1, stride=8, alpha=0.0001, display_iter=300, title='', preprocessing=None): iter_num = 0 img_perturbed_k = np.copy(img_0) img_perturbed_k_1 = np.copy(img_0) W_cat, w_cat, w_0_cat = get_parameters(mean_cat, cov_cat, pi_cat) W_grass, w_grass, w_0_grass = get_parameters(mean_grass, cov_grass, pi_grass) while iter_num < 300: iter_num += 1 grad = np.zeros_like(img_0) for i in range(4, img_0.shape[0] - 4, stride): #loop starting form zero to center the output for j in range( 4, img_0.shape[1] - 4, stride): #loop starting form zero to center the output patch_vec_0 = img_0[i - 4:i + 4, j - 4:j + 4].reshape((64, 1)) patch_vec_k = img_perturbed_k[i - 4:i + 4, j - 4:j + 4].reshape((64, 1)) grad[i - 4:i + 4, j - 4:j + 4] += gradient_CW( patch_vec_k=patch_vec_k, patch_vec_0=patch_vec_0, mean_cat=mean_cat, cov_cat=cov_cat, pi_cat=pi_cat, mean_grass=mean_grass, cov_grass=cov_grass, pi_grass=pi_grass, W_cat=W_cat, w_cat=w_cat, w_0_cat=w_0_cat, W_grass=W_grass, w_grass=w_grass, w_0_grass=w_0_grass, l=l, target_index=target_index).reshape((8, 8)) img_perturbed_k_1 = np.clip(img_perturbed_k - alpha * grad, 0, 1) change = np.linalg.norm((img_perturbed_k_1 - img_perturbed_k)) img_perturbed_k = img_perturbed_k_1 if (iter_num) % display_iter == 0: print("\n") display_image(img_perturbed=img_perturbed_k, mean_cat=mean_cat, cov_cat=cov_cat, pi_cat=pi_cat, mean_grass=mean_grass, cov_grass=cov_grass, pi_grass=pi_grass, original_img=original_img, truth=truth, title=title + 'iter_' + str(iter_num), stride=stride, preprocessing=preprocessing) print(' Change:{}'.format(change)) if change < 0.001 and stride == 8: break elif change < 0.01 and stride == 1: break return img_perturbed_k
def main(self): params = utils.get_parameters(sys.argv[2]) method = self.patterns.get(params.get('mode')) if not method: return self.menu() return method(**params)
mu=mu, theta=theta, sigma=sigma, gamma=gamma, tau=tau, train_type=TRAIN_TYPE, actor_lr=actor_lr, critic_lr=critic_lr, batch_size=batch_size, hmm_state=hmm_state) # define ROS service client and messages rospy.wait_for_service('/gazebo_env_io/pytorch_io_service') pytorch_io_service = rospy.ServiceProxy('/gazebo_env_io/pytorch_io_service', SimpleCtrl) TERMINAL_REWARD, COLLISION_REWARD, SURVIVE_REWARD = utils.get_parameters( '../../gazebo_drl_env/param/env.yaml') # load parameters and experiences if CONTINUE_TRAIN is True: model.load_models() model.copy_weights() #model.load_buffer() losses = [] model.noise.reset() succeed_time = 0 crash_time = 0 max_test_success_time = 0 max_total_reward = -99999 # time profiling
def main(): #LOAD CONFIGS################################################################ args = get_args() import os os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_no log_format = '[%(asctime)s] %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%d %I:%M:%S') t = time.time() local_time = time.localtime(t) if not os.path.exists('./log'): os.mkdir('./log') fh = logging.FileHandler(os.path.join('log/train-{}{:02}{}'.format(local_time.tm_year % 2000, local_time.tm_mon, t))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) use_gpu = False if torch.cuda.is_available(): use_gpu = True # cudnn.enabled=True torch.cuda.manual_seed(str(args.rand_seed)) random.seed(args.rand_seed) #LOAD DATA################################################################### def convert_param(original_lists): ctype, value = original_lists[0], original_lists[1] is_list = isinstance(value, list) if not is_list: value = [value] outs = [] for x in value: if ctype == 'int': x = int(x) elif ctype == 'str': x = str(x) elif ctype == 'bool': x = bool(int(x)) elif ctype == 'float': x = float(x) elif ctype == 'none': if x.lower() != 'none': raise ValueError('For the none type, the value must be none instead of {:}'.format(x)) x = None else: raise TypeError('Does not know this type : {:}'.format(ctype)) outs.append(x) if not is_list: outs = outs[0] return outs if args.dataset == 'cifar100': mean = [x / 255 for x in [129.3, 124.1, 112.4]] std = [x / 255 for x in [68.2, 65.4, 70.4]] lists = [transforms.RandomHorizontalFlip(), transforms.RandomCrop(32, padding=4), transforms.ToTensor(), transforms.Normalize(mean, std)] transform_train = transforms.Compose(lists) transform_test = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean, std)]) with open('../data/cifar-split.txt', 'r') as f: data = json.load(f) content = { k: convert_param(v) for k,v in data.items()} Arguments = namedtuple('Configure', ' '.join(content.keys())) content = Arguments(**content) cifar_split = content train_split, valid_split = cifar_split.train, cifar_split.valid print(len(train_split),len(valid_split)) train_dataset = datasets.CIFAR100(root='../data', train=True, download=True, transform=transform_train) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=False,sampler=torch.utils.data.sampler.SubsetRandomSampler(train_split), num_workers=4, pin_memory=use_gpu) train_dataprovider = DataIterator(train_loader) val_loader = torch.utils.data.DataLoader( datasets.CIFAR100(root='../data', train=True, download=True, transform=transform_test), batch_size=250, shuffle=False, sampler=torch.utils.data.sampler.SubsetRandomSampler(valid_split), num_workers=4, pin_memory=use_gpu ) val_dataprovider = DataIterator(val_loader) print('load data successfully') CLASS = 100 elif args.dataset == 'cifar10': mean = [x / 255 for x in [125.3, 123.0, 113.9]] std = [x / 255 for x in [63.0, 62.1, 66.7]] lists = [transforms.RandomHorizontalFlip(), transforms.RandomCrop(32, padding=4), transforms.ToTensor(), transforms.Normalize(mean, std)] transform_train = transforms.Compose(lists) transform_test = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean, std)]) with open('../data/cifar-split.txt', 'r') as f: data = json.load(f) content = { k: convert_param(v) for k,v in data.items()} Arguments = namedtuple('Configure', ' '.join(content.keys())) content = Arguments(**content) cifar_split = content train_split, valid_split = cifar_split.train, cifar_split.valid print(len(train_split),len(valid_split)) train_dataset = datasets.CIFAR10(root='../data', train=True, download=True, transform=transform_train) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=False,sampler=torch.utils.data.sampler.SubsetRandomSampler(train_split), num_workers=4, pin_memory=use_gpu) train_dataprovider = DataIterator(train_loader) val_loader = torch.utils.data.DataLoader( datasets.CIFAR10(root='../data', train=True, download=True, transform=transform_test), batch_size=250, shuffle=False, sampler=torch.utils.data.sampler.SubsetRandomSampler(valid_split), num_workers=4, pin_memory=use_gpu ) val_dataprovider = DataIterator(val_loader) print('load data successfully') CLASS = 10 elif args.dataset == 'image16': mean = [x / 255 for x in [122.68, 116.66, 104.01]] std = [x / 255 for x in [63.22, 61.26 , 65.09]] transform_test = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean, std)]) with open('../data/ImageNet16-120-split.txt', 'r') as f: data = json.load(f) content = { k: convert_param(v) for k,v in data.items()} Arguments = namedtuple('Configure', ' '.join(content.keys())) content = Arguments(**content) img_split = content train_split, valid_split = img_split.train, img_split.valid train_split = train_split[:len(train_split)//args.batch_size*args.batch_size] valid_split = valid_split[:len(valid_split)//250*250] print(len(train_split),len(valid_split)) train_dataset = ImageNet16('../data', True , transform_test,120) test_dataset = ImageNet16('../data', True, transform_test,120) train_loader = torch.utils.data.DataLoader( train_dataset, batch_size=args.batch_size, shuffle=False,sampler=torch.utils.data.sampler.SubsetRandomSampler(train_split), num_workers=4, pin_memory=use_gpu) train_dataprovider = DataIterator(train_loader) val_loader = torch.utils.data.DataLoader( test_dataset, batch_size=250, shuffle=False, sampler=torch.utils.data.sampler.SubsetRandomSampler(valid_split), num_workers=4, pin_memory=use_gpu ) val_dataprovider = DataIterator(val_loader) print('load data successfully') CLASS = 120 print(CLASS) print(args.init_channels,args.stacks//3) model = TinyNetwork(C=args.init_channels,N=args.stacks//3,max_nodes = 4, num_classes = CLASS, search_space = NAS_BENCH_201, affine = False, track_running_stats = False).cuda() optimizer = torch.optim.SGD(get_parameters(model), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) criterion_smooth = CrossEntropyLabelSmooth(CLASS, 0.1) if use_gpu: loss_function = criterion_smooth.cuda() device = torch.device("cuda" ) else: loss_function = criterion_smooth device = torch.device("cpu") scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer,args.total_iters) model = model.to(device) all_iters = 0 if args.auto_continue: lastest_model, iters = get_lastest_model() if lastest_model is not None: all_iters = iters checkpoint = torch.load(lastest_model, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint['state_dict'], strict=True) print('load from checkpoint') for i in range(iters): scheduler.step() args.optimizer = optimizer args.loss_function = loss_function args.scheduler = scheduler args.train_dataprovider = train_dataprovider args.val_dataprovider = val_dataprovider args.evo_controller = evolutionary(args.max_population,args.select_number, args.mutation_len,args.mutation_number,args.p_opwise,args.evo_momentum) path = './record_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}_{}'.format(args.dataset,args.stacks,args.init_channels,args.total_iters,args.warmup_iters,args.max_population,args.select_number,args.mutation_len,args.mutation_number,args.val_interval,args.p_opwise,args.evo_momentum,args.rand_seed) logging.info(path) model.current_N = 1 while all_iters < args.total_iters: if all_iters in [15000,30000,45000,60000]: # if all_iters in [50,100,150,200]: # print("----------") model.current_N += 1 if all_iters > 1 and all_iters % args.val_interval == 0: results = [] for structure_father in args.evo_controller.group: results.append([structure_father.structure,structure_father.loss,structure_father.count]) if not os.path.exists(path): os.mkdir(path) with open(path + '/%06d-ep.txt'%all_iters,'w') as tt: json.dump(results,tt) if all_iters >= args.warmup_iters:#warmup args.evo_controller.select() all_iters = train(model, device, args, val_interval=args.val_interval, bn_process=False, all_iters=all_iters) validate(model, device, args, all_iters=all_iters) results = [] for structure_father in args.evo_controller.group: results.append([structure_father.structure,structure_father.loss,structure_father.count]) with open(path + '/%06d-ep.txt'%all_iters,'w') as tt: json.dump(results,tt)
def main(args): torch.manual_seed(args.seed) np.random.seed(args.seed) model = args.model params = get_parameters(model) params['device'] = torch.device("cuda:0" if args.cuda else "cpu") print(params['device']) dpmm = NeuralClustering(params).to(params['device']) data_generator = get_generator(params) #define containers to collect statistics losses = [] # NLLs accs = [] # Accuracy of the classification prediction perm_vars = [] # permutation variance it = 0 # iteration counter learning_rate = 1e-4 weight_decay = 0.01 optimizer = torch.optim.Adam(dpmm.parameters(), lr=learning_rate, weight_decay=weight_decay) perms = 6 # Number of permutations for each mini-batch. # In each permutation, the order of the datapoints is shuffled. batch_size = args.batch_size max_it = args.iterations if params['model'] == 'Gauss2D': if not os.path.isdir('saved_models/Gauss2D'): os.makedirs('saved_models/Gauss2D') if not os.path.isdir('figures/Gauss2D'): os.makedirs('figures/Gauss2D') elif params['model'] == 'MNIST': if not os.path.isdir('saved_models/MNIST'): os.makedirs('saved_models/MNIST') if not os.path.isdir('figures/MNIST'): os.makedirs('figures/MNIST') end_name = params['model'] learning_rates = {1200: 5e-5, 2200: 1e-5} t_start = time.time() itt = it while True: it += 1 if it == max_it: break dpmm.train() if it % args.plot_interval == 0: torch.cuda.empty_cache() plot_avgs(losses, accs, perm_vars, 50, save_name='./figures/train_avgs_' + end_name + '.pdf') if params['model'] == 'Gauss2D': fig_name = './figures/Gauss2D/samples_2D_' + str(it) + '.pdf' print('\nCreating plot at ' + fig_name + '\n') plot_samples_2d(dpmm, data_generator, N=100, seed=it, save_name=fig_name) elif params['model'] == 'MNIST': fig_name = './figures/MNIST/samples_MNIST_' + str(it) + '.pdf' print('\nCreating plot at ' + fig_name + '\n') plot_samples_MNIST(dpmm, data_generator, N=20, seed=it, save_name=fig_name) if it % 100 == 0: if 'fname' in vars(): os.remove(fname) dpmm.params['it'] = it fname = 'saved_models/' + end_name + '/' + end_name + '_' + str( it) + '.pt' torch.save(dpmm, fname) if it in learning_rates: optimizer = torch.optim.Adam(dpmm.parameters(), lr=learning_rates[it], weight_decay=weight_decay) data, cs, clusters, K = data_generator.generate(None, batch_size) N = data.shape[1] loss_values = np.zeros(perms) accuracies = np.zeros([N - 1, perms]) # The memory requirements change in each iteration according to the random values of N and K. # If both N and K are big, an out of memory RuntimeError exception might be raised. # When this happens, we capture the exception, reduce the batch_size to 3/4 of its value, and try again. while True: try: loss = 0 for perm in range(perms): arr = np.arange(N) np.random.shuffle( arr ) # permute the order in which the points are queried cs = cs[arr] data = data[:, arr, :] cs = relabel( cs ) # this makes cluster labels appear in cs[] in increasing order this_loss = 0 dpmm.previous_n = 0 for n in range(1, N): # points up to (n-1) are already assigned, the point n is to be assigned logprobs = dpmm(data, cs, n) c = cs[n] accuracies[n - 1, perm] = np.sum( np.argmax(logprobs.detach().to('cpu').numpy(), axis=1) == c) / logprobs.shape[0] this_loss -= logprobs[:, c].mean() this_loss.backward( ) # this accumulates the gradients for each permutation loss_values[perm] = this_loss.item() / N loss += this_loss perm_vars.append(loss_values.var()) losses.append(loss.item() / N) accs.append(accuracies.mean()) optimizer.step( ) # the gradients used in this step are the sum of the gradients for each permutation optimizer.zero_grad() print('{0:4d} N:{1:2d} K:{2} Mean NLL:{3:.3f} Mean Acc:{4:.3f} Mean Permutation Variance: {5:.7f} Mean Time/Iteration: {6:.1f}'\ .format(it, N, K , np.mean(losses[-50:]), np.mean(accs[-50:]), np.mean(perm_vars[-50:]), (time.time()-t_start)/(it - itt) )) break except RuntimeError: bsize = int(.75 * data.shape[0]) if bsize > 2: print('RuntimeError handled ', 'N:', N, ' K:', K, 'Trying batch size:', bsize) data = data[:bsize, :, :] else: break
if (__name__ == "__main__" ): log('v%s started' % __settings__.getAddonInfo("version"), xbmc.LOGNOTICE) HANDLE = int(sys.argv[1]) if not (__settings__.getSetting("firstrun")): __settings__.openSettings() #TODO fix this if utils.pass_setup_test(sabnzbd.self_test(), __settings__.getSetting("sabnzbd_incomplete")): __settings__.setSetting("firstrun", '1') else: if (not sys.argv[2]): add_posts({'title':'Incomplete'}, '', MODE_INCOMPLETE) add_posts({'title':'Browse local NZB\'s'}, '', MODE_LOCAL, '', '') xbmcplugin.setContent(HANDLE, 'movies') xbmcplugin.endOfDirectory(HANDLE, succeeded=True, cacheToDisc=True) else: params = utils.get_parameters(sys.argv[2]) get = params.get if get("mode")== MODE_PLAY: is_home, sab_nzo_id = is_nzb_home(params) if is_home: nzbname = utils.unquote_plus(get("nzbname")) pre_play(nzbname, nzo=sab_nzo_id) if get("mode")== MODE_LIST_PLAY or get("mode")== MODE_AUTO_PLAY: play_video(params) if get("mode")== MODE_DELETE: delete(params) if get("mode")== MODE_DOWNLOAD: download(params) if get("mode")== MODE_REPAIR: repair(params) if get("mode")== MODE_INCOMPLETE:
def get_cand_err(model, cand, args): global train_dataprovider, val_dataprovider if train_dataprovider is None: use_gpu = False train_dataprovider = get_train_dataprovider(args.train_batch_size, use_gpu=True, num_workers=32) val_dataprovider = get_val_dataprovider(args.test_batch_size, use_gpu=True, num_workers=32) if torch.cuda.is_available(): device = torch.device('cuda') else: device = torch.device('cpu') max_train_iters = args.max_train_iters max_test_iters = args.max_test_iters print('clear bn statics....') # for m in model.modules(): # if isinstance(m, torch.nn.BatchNorm2d): # m.running_mean = torch.zeros_like(m.running_mean) # m.running_var = torch.ones_like(m.running_var) print('train bn with training set (BN sanitize) ....') # meta_model = ShuffleNetV2_OneShot() # meta_model = nn.DataParallel(meta_model) # meta_model = meta_model.to(device) # for p, q in zip(model.parameters(), meta_model.parameters()): # if p is not None: # q = p.clone() optimizer = torch.optim.SGD(get_parameters(model), lr=0.001) criterion_smooth = CrossEntropyLabelSmooth(1000, 0.1) loss_function = criterion_smooth.cuda() model.train() for step in tqdm.tqdm(range(max_train_iters)): # print('train step: {} total: {}'.format(step,max_train_iters)) data, target = train_dataprovider.next() # print('get data',data.shape) target = target.type(torch.LongTensor) data, target = data.to(device), target.to(device) # print(type(data)) # data = data.requires_grad_() # data = torch.tensor(data.data, requires_grad=True) # data = data.cuda() # # target.requires_grad=True output = model(data, cand) # if step<10: # loss = loss_function(output, target) # optimizer.zero_grad() # loss.backward() # optimizer.step() del data, target, output top1 = 0 top5 = 0 total = 0 print('starting test....') model.eval() for step in tqdm.tqdm(range(max_test_iters)): # print('test step: {} total: {}'.format(step,max_test_iters)) data, target = val_dataprovider.next() batchsize = data.shape[0] # print('get data',data.shape) target = target.type(torch.LongTensor) data, target = data.to(device), target.to(device) logits = model(data, cand) prec1, prec5 = accuracy(logits, target, topk=(1, 5)) # print(prec1.item(),prec5.item()) top1 += prec1.item() * batchsize top5 += prec5.item() * batchsize total += batchsize del data, target, logits, prec1, prec5 top1, top5 = top1 / total, top5 / total top1, top5 = 1 - top1 / 100, 1 - top5 / 100 print('top1: {:.2f} top5: {:.2f}'.format(top1 * 100, top5 * 100)) return top1, top5
def cross_fold(model_generator, frac, epochs, K, optimiser_generator, scheduler_generator, step_every, output_to_std=False): means = None sds = None times = None for k in range(K): train_set = df.sample(frac=frac) test_set = df.drop(train_set.index) parameters = utils.get_parameters() train_y = train_set.iloc[:, -len(parameters):] train_x = train_set.iloc[:, :-len(parameters)] test_y = test_set.iloc[:, -len(parameters):] test_x = test_set.iloc[:, :-len(parameters)] train_data_set = FingerprintDataset(train_x, train_y) test_data_set = FingerprintDataset(test_x, test_y) train_loader = DataLoader(train_data_set, batch_size=64, shuffle=True) test_loader = DataLoader(test_data_set, batch_size=64, shuffle=False) network = model_generator() optimiser = optimiser_generator(network) scheduler = scheduler_generator( optimiser) if scheduler_generator is not None else None for epoch in range(epochs): epoch_loss = 0 for batch in train_loader: optimiser.zero_grad() loss_func = torch.nn.MSELoss() loss = loss_func(network(batch['fingerprint']), batch['parameters'].float()) loss.backward() optimiser.step() epoch_loss += loss.item() if scheduler is not None and epoch % step_every == 0 and epoch != 0: scheduler.step() if output_to_std: print('Epoch [%d/%d] loss %f' % (epoch, epochs, epoch_loss / len(train_loader))) validation_loss = None total_time = 0 with torch.no_grad(): for batch in test_loader: start = time.perf_counter() predicted_values = network(batch['fingerprint']) end = time.perf_counter() total_time += end - start expected_values = batch['parameters'] percentage_error = torch.div( torch.abs(expected_values - predicted_values), expected_values) if validation_loss is None: validation_loss = percentage_error else: validation_loss = torch.cat( [validation_loss, percentage_error]) average_time = total_time / len(test_loader) if means is None and sds is None: means = torch.mean(validation_loss, 0).unsqueeze(0) sds = torch.std(validation_loss, 0).unsqueeze(0) times = average_time else: means = torch.cat( [means, torch.mean(validation_loss, 0).unsqueeze(0)]) sds = torch.cat([sds, torch.std(validation_loss, 0).unsqueeze(0)]) times += average_time return (torch.mean(means, 0), torch.mean(sds, 0), torch.tensor(times / k))
def main(): # 0. input arguments parser = argparse.ArgumentParser() parser.add_argument('-g', '--gpu', type=int, help='GPU device to use', default=0) parser.add_argument('-d', '--dataset', help='VOC, CamVid, SUNRGBD, Custom', default='CamVid') parser.add_argument('-dr', '--datasetroot', help='dataset root pth', default='/home/hongkai/PycharmProjects/Datasets') parser.add_argument('-dt', '--degradedtrain', help='o, bg, bm, hi, ho, ns, nsp', default='o') parser.add_argument('-dv', '--degradedval', help='o, bg, bm, hi, ho, ns, nsp', default='o') parser.add_argument('-ds', '--degradedtest', help='o, bg, bm, hi, ho, ns, nsp', default='o') parser.add_argument('-c', '--config', type=int, default=1, choices=configurations.keys()) parser.add_argument('-r', '--resume', help='Checkpoint path') args = parser.parse_args() gpu = args.gpu dataset = args.dataset dataset_root = args.datasetroot degradedtrain = args.degradedtrain degradedval = args.degradedval degradedtest = args.degradedtest cfg = configurations[args.config] out = utils.get_log_dir('fcn8s-atonce', args.config, cfg) resume = args.resume os.environ['CUDA_VISIBLE_DEVICES'] = str(gpu) cuda = torch.cuda.is_available() torch.manual_seed(1337) if cuda: torch.cuda.manual_seed(1337) # 1. dataset root = osp.expanduser(osp.join(dataset_root, dataset)) kwargs = {'num_workers': 4, 'pin_memory': True} if cuda else {} if dataset == 'VOC': train_data = datasets.VOCSeg(root, split='train', dataset=degradedtrain, transform=True) val_data = datasets.VOCSeg(root, split='val', dataset=degradedval, transform=True) test_data = datasets.VOCSeg(root, split='test', dataset=degradedtest, transform=True) elif dataset == "CamVid": train_data = datasets.CamVidSeg(root, split='train', dataset=degradedtrain, transform=True) val_data = datasets.CamVidSeg(root, split='val', dataset=degradedval, transform=True) test_data = datasets.CamVidSeg(root, split='test', dataset=degradedtest, transform=True) elif dataset == "Cityscapes": train_data = datasets.CityscapesSeg(root, split='train', dataset=degradedtrain, transform=True) val_data = datasets.CityscapesSeg(root, split='val', dataset=degradedval, transform=True) test_data = datasets.CityscapesSeg(root, split='test', dataset=degradedtest, transform=True) elif dataset == "Custom": train_data = datasets.CustomSeg(root, split='train', dataset=degradedtrain, transform=True) val_data = datasets.CustomSeg(root, split='val', dataset=degradedval, transform=True) test_data = datasets.CustomSeg(root, split='test', dataset=degradedtest, transform=True) else: train_data = datasets.SUNSeg(root, split='train', dataset=degradedtrain, transform=True) val_data = datasets.SUNSeg(root, split='val', dataset=degradedval, transform=True) test_data = datasets.SUNSeg(root, split='test', dataset=degradedtest, transform=True) train_loader = torch.utils.data.DataLoader(train_data, batch_size=1, shuffle=True, **kwargs) val_loader = torch.utils.data.DataLoader(val_data, batch_size=1, shuffle=False, **kwargs) test_loader = torch.utils.data.DataLoader(test_data, batch_size=1, shuffle=False, **kwargs) # 2. model model = models.FCN8sAtOnce(n_class=train_data.n_classes) start_epoch = 0 start_iteration = 0 if resume: checkpoint = torch.load(resume) model.load_state_dict(checkpoint['model_state_dict']) start_epoch = checkpoint['epoch'] start_iteration = checkpoint['iteration'] else: vgg16 = torchfcn.models.VGG16(pretrained=True) model.copy_params_from_vgg16(vgg16) device = torch.device("cuda" if cuda else "cpu") model = model.to(device) # 3. optimizer optim = torch.optim.SGD( [ {'params': utils.get_parameters(model, bias=False)}, {'params': utils.get_parameters(model, bias=True), 'lr': cfg['lr'] * 2, 'weight_decay': 0}, ], lr=cfg['lr'], momentum=cfg['momentum'], weight_decay=cfg['weight_decay']) if resume: optim.load_state_dict(checkpoint['optim_state_dict']) # 4. trainer trainer = Trainer( cuda=cuda, model=model, optimizer=optim, train_loader=train_loader, val_loader=val_loader, test_loader=test_loader, out=out, max_iter=cfg['max_iteration'], interval_validate=cfg.get('interval_validate', len(train_loader)), ) trainer.epoch = start_epoch trainer.iteration = start_iteration trainer.train()
def main(): args = get_args() # archLoader arch_loader = ArchLoader(args.path) # Log log_format = '[%(asctime)s] %(message)s' logging.basicConfig(stream=sys.stdout, level=logging.INFO, format=log_format, datefmt='%m-%d %I:%M:%S') t = time.time() local_time = time.localtime(t) if not os.path.exists('./log'): os.mkdir('./log') fh = logging.FileHandler( os.path.join('log/train-{}-{:02}-{:02}-{:.3f}'.format( local_time.tm_year % 2000, local_time.tm_mon, local_time.tm_mday, t))) fh.setFormatter(logging.Formatter(log_format)) logging.getLogger().addHandler(fh) use_gpu = False if torch.cuda.is_available(): use_gpu = True kwargs = {'num_workers': 4, 'pin_memory': True} train_loader = torch.utils.data.DataLoader(datasets.MNIST( root="./data", train=True, download=True, transform=transforms.Compose([ transforms.Resize(32), transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])), batch_size=args.batch_size, shuffle=True, **kwargs) val_loader = torch.utils.data.DataLoader(datasets.MNIST( root="./data", train=False, transform=transforms.Compose([ transforms.Resize(32), transforms.ToTensor(), transforms.Normalize((0.1307, ), (0.3081, )) ])), batch_size=args.batch_size, shuffle=False, **kwargs) model = mutableResNet20(num_classes=10) base_model = copy.deepcopy(model) logging.info('load model successfully') optimizer = torch.optim.SGD(get_parameters(model), lr=args.learning_rate, momentum=args.momentum, weight_decay=args.weight_decay) criterion_smooth = CrossEntropyLabelSmooth(1000, 0.1) if use_gpu: model = nn.DataParallel(model) loss_function = criterion_smooth.cuda() device = torch.device("cuda") base_model.cuda() else: loss_function = criterion_smooth device = torch.device("cpu") # scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, # lambda step: (1.0-step/args.total_iters) if step <= args.total_iters else 0, last_epoch=-1) scheduler = CosineAnnealingWarmRestarts(optimizer, T_0=5) # scheduler = torch.optim.lr_scheduler.CosineAnnealingLR( # optimizer, T_max=200) model = model.to(device) all_iters = 0 if args.auto_continue: lastest_model, iters = get_lastest_model() if lastest_model is not None: all_iters = iters checkpoint = torch.load(lastest_model, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint['state_dict'], strict=True) logging.info('load from checkpoint') for i in range(iters): scheduler.step() # 参数设置 args.optimizer = optimizer args.loss_function = loss_function args.scheduler = scheduler args.train_loader = train_loader args.val_loader = val_loader if args.eval: if args.eval_resume is not None: checkpoint = torch.load(args.eval_resume, map_location=None if use_gpu else 'cpu') model.load_state_dict(checkpoint, strict=True) validate(model, device, args, all_iters=all_iters, arch_loader=arch_loader) exit(0) # warmup weights if args.warmup is not None: logging.info("begin warmup weights") while all_iters < args.warmup: all_iters = train_supernet(model, device, args, bn_process=False, all_iters=all_iters) validate(model, device, args, all_iters=all_iters, arch_loader=arch_loader) while all_iters < args.total_iters: all_iters = train_subnet(model, base_model, device, args, bn_process=False, all_iters=all_iters, arch_loader=arch_loader) logging.info("validate iter {}".format(all_iters)) if all_iters % 9 == 0: validate(model, device, args, all_iters=all_iters, arch_loader=arch_loader) validate(model, device, args, all_iters=all_iters, arch_loader=arch_loader)