def __init__(self, root_fp, project_qualified_name): self.root_fp = root_fp self.project_qualified_name = project_qualified_name neptune.init(self.project_qualified_name) neptune.set_project(self.project_qualified_name) self.project = neptune.project self.leaderboard = self.project.get_leaderboard()
def main(tasks, features): neptune.set_project('sfczekalski/BiasSF') neptune.init('sfczekalski/BiasSF') neptune.create_experiment(name='Bias summary, raw') fraction_range = [0.0, 0.05, 0.1, 0.15, 0.2, 0.3, 0.4, 0.5, 0.7, 1.0] for task in tasks: print(f'{task}'.upper()) for feature in features: print(f'{feature}'.upper()) bias_benchmark(task, feature, fraction_range, plot=False) neptune.stop()
def __init__(self, log, project_name, experiment_name, experiment_params, experiment_tags): logging.getLogger('neptune').setLevel(logging.ERROR) self.log = log self.project = None self.experiment = None self._optuna_callback = None self._keras_callback = None self._experiment_name = None if self.log: self.project = npt.set_project(project_qualified_name=project_name) self.experiment = npt.create_experiment(name=experiment_name, params=experiment_params) for tag in experiment_tags: self.experiment.append_tags(tag)
import neptune import numpy as np import pandas as pd import matplotlib.pyplot as plt from sklearn.cluster import AgglomerativeClustering, KMeans from simforest.cluster import SimilarityForestCluster from sklearn.metrics import davies_bouldin_score, silhouette_score import hdbscan from scipy.stats import ttest_ind from sklearn.decomposition import PCA from examples.cluster.clustering_datasets import get_datasets # init project neptune.set_project('sfczekalski/SimilarityForest') neptune.init('sfczekalski/SimilarityForest') # set model properties params = dict() params['max_depth'] = 5 params['n_estimators'] = 20 params['technique'] = 'hdbscan' params['bootstrap'] = False params['sim_function'] = 'dot' # set experiment properties n_iterations = 20 plot = True other_algorithm = 'hdbscan' # create experiment
def train(cfg): """ Train a video model for many epochs on train set and evaluate it on val set. Args: cfg (CfgNode): configs. Details can be found in slowfast/config/defaults.py """ # Set random seed from configs. np.random.seed(cfg.RNG_SEED) torch.manual_seed(cfg.RNG_SEED) # Setup logging format. logging.setup_logging(cfg) # Print config. logger.info("Train with config:") logger.info(pprint.pformat(cfg)) if du.get_rank()==0 and du.is_master_proc(num_gpus=cfg.NUM_GPUS): writer = SummaryWriter(log_dir=cfg.OUTPUT_DIR) else: writer = None if du.get_rank()==0 and du.is_master_proc(num_gpus=cfg.NUM_GPUS) and not cfg.DEBUG: tags = [] if 'TAGS' in cfg and cfg.TAGS !=[]: tags=list(cfg.TAGS) neptune.set_project('Serre-Lab/motion') ###################### overrides = sys.argv[1:] overrides_dict = {} for i in range(len(overrides)//2): overrides_dict[overrides[2*i]] = overrides[2*i+1] overrides_dict['dir'] = cfg.OUTPUT_DIR ###################### if 'NEP_ID' in cfg and cfg.NEP_ID != "": session = Session() project = session.get_project(project_qualified_name='Serre-Lab/motion') nep_experiment = project.get_experiments(id=cfg.NEP_ID)[0] else: nep_experiment = neptune.create_experiment (name=cfg.NAME, params=overrides_dict, tags=tags) else: nep_experiment=None # Build the video model and print model statistics. model = build_model(cfg) if du.is_master_proc(num_gpus=cfg.NUM_GPUS): misc.log_model_info(model, cfg, is_train=True) # Construct the optimizer. optimizer = optim.construct_optimizer(model, cfg) # Load a checkpoint to resume training if applicable. if cfg.TRAIN.AUTO_RESUME and cu.has_checkpoint(cfg.OUTPUT_DIR): logger.info("Load from last checkpoint.") last_checkpoint = cu.get_last_checkpoint(cfg.OUTPUT_DIR) checkpoint_epoch = cu.load_checkpoint( last_checkpoint, model, cfg.NUM_GPUS > 1, optimizer ) start_epoch = checkpoint_epoch + 1 elif cfg.TRAIN.CHECKPOINT_FILE_PATH != "": logger.info("Load from given checkpoint file.") checkpoint_epoch = cu.load_checkpoint( cfg.TRAIN.CHECKPOINT_FILE_PATH, model, cfg.NUM_GPUS > 1, optimizer, inflation=cfg.TRAIN.CHECKPOINT_INFLATE, convert_from_caffe2=cfg.TRAIN.CHECKPOINT_TYPE == "caffe2", ) start_epoch = checkpoint_epoch + 1 else: start_epoch = 0 # Create the video train and val loaders. train_loader = loader.construct_loader(cfg, "train") val_loader = loader.construct_loader(cfg, "val") # Create meters. if cfg.DETECTION.ENABLE: train_meter = AVAMeter(len(train_loader), cfg, mode="train") val_meter = AVAMeter(len(val_loader), cfg, mode="val") else: train_meter = TrainMeter(len(train_loader), cfg) val_meter = ValMeter(len(val_loader), cfg) # Perform the training loop. logger.info("Start epoch: {}".format(start_epoch + 1)) for cur_epoch in range(start_epoch, cfg.SOLVER.MAX_EPOCH): # Shuffle the dataset. loader.shuffle_dataset(train_loader, cur_epoch) # Train for one epoch. train_epoch(train_loader, model, optimizer, train_meter, cur_epoch, writer, nep_experiment, cfg) # Compute precise BN stats. # if cfg.BN.USE_PRECISE_STATS and len(get_bn_modules(model)) > 0: # calculate_and_update_precise_bn( # train_loader, model, cfg.BN.NUM_BATCHES_PRECISE # ) # Save a checkpoint. if cu.is_checkpoint_epoch(cur_epoch, cfg.TRAIN.CHECKPOINT_PERIOD): cu.save_checkpoint(cfg.OUTPUT_DIR, model, optimizer, cur_epoch, cfg) # Evaluate the model on validation set. if misc.is_eval_epoch(cfg, cur_epoch): eval_epoch(val_loader, model, val_meter, cur_epoch, nep_experiment, cfg) if du.get_rank()==0 and du.is_master_proc(num_gpus=cfg.NUM_GPUS) and not cfg.DEBUG: nep_experiment.log_metric('epoch', cur_epoch)
"num_leaves": 80, "seed": 23, "objective": "regression", "boosting_type": "gbdt", "min_data_in_leaf": 200, "learning_rate": 0.02, "feature_fraction": 0.8, "bagging_fraction": 0.7, "bagging_freq": 1, "metric": "l2", "num_boost_round": 5000, } callbacks = [] if NEPTUNE: neptune.set_project("lccambiaghi/kaggle-m5") neptune.create_experiment( name=f"lightgbm", send_hardware_metrics=False, run_monitoring_thread=False, params=PARAMS, ) callbacks.append(neptune_monitor(prefix=f'h{forecast_horizon}_')) model = lgb.train(PARAMS, train_set, early_stopping_rounds=125, verbose_eval=100, valid_sets=[train_set, val_set], callbacks=callbacks)
params[key]=True elif params[key] == 'False': params[key]=False if( key in ['batch_size','num_classes','hidden_size','supervised_layer_pos','num_supervised_heads','random_seed','max_length']): if(params[key]!='N/A'): params[key]=int(params[key]) if((key == 'weights') and (params['auto_weights']==False)): params[key] = ast.literal_eval(params[key]) params['best_params']=True ##### change in logging to output the results to neptune params['logging']='local' if(params['logging']=='neptune'): from api_config import project_name,api_token neptune.init(project_name,api_token=api_token) neptune.set_project(project_name) torch.autograd.set_detect_anomaly(True) if torch.cuda.is_available() and params['device']=='cuda': # Tell PyTorch to use the GPU. device = torch.device("cuda") ##### You can set the device manually if you have only one gpu ##### comment this line if you don't want to manually set the gpu deviceID = get_gpu() torch.cuda.set_device(deviceID[0]) ##### comment this line if you don't want to manually set the gpu #### parameter required is the gpu id #torch.cuda.set_device(0) else: print('Since you dont want to use GPU, using the CPU instead.') device = torch.device("cpu")
def __init__(self, tags): neptune.set_project('pixelneo/whoosh') neptune.create_experiment() for tag in tags: neptune.append_tag(tag)
import os import subprocess from PIL import Image import neptune DEFAULT_DATA_ROOT = '/home/elijahc/projects/vae' proj = neptune.set_project('elijahc/DuplexAE') exp = proj.get_experiments(id=['DPX-65'])[0] def model_dir(exp=exp, data_root=DEFAULT_DATA_ROOT): mod_dir = os.path.join(*[ data_root, exp.get_properties()['dir'], ]) return mod_dir def img_dir(exp=exp, data_root=DEFAULT_DATA_ROOT): return os.path.join(model_dir(), 'recons') def log_gif(exp=exp, data_root=DEFAULT_DATA_ROOT): gif_path = os.path.join(img_dir(), 'recon_learning_optimized.gif') if os.path.exists(gif_path): exp.log_artifact(gif_path) else:
import os import fast_fgvr_semi_train os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' import neptune neptune.set_project('Leaves/leaves') if __name__ == '__main__': gpu_number = 3 #,, for l in [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ]: #l=0 num_trials = 1 arg_db_name = 'leaves_fossils_out' arg_net = 'resnet50_leaves' arg_train_mode = 'hard_anchor_fossils' lr = '0.01' for idx in range(num_trials): args = [ '--gpu', '1', '--db_name', arg_db_name, '--label_out', str(l), '--net', arg_net,
def train_job(model_name, detector_name, train_df, valid_df, model_ckpt=None, log=True): # exp_name = FLAGS["exp_name"] if log: neptune.set_project("utsav/wheat-det") neptune.init("utsav/wheat-det", api_token=NEPTUNE_API_TOKEN) neptune.create_experiment( FLAGS["exp_name"], exp_description, params=FLAGS, upload_source_files="*.txt", ) best_score = 0.0 start_epoch = 0 datasets = get_training_datasets(train_df, valid_df) train_loader = DataLoader( datasets["train"], batch_size=FLAGS["batch_size"], num_workers=FLAGS["num_workers"], shuffle=True, # shuffle=True, # sampler=sampler collate_fn=collate_fn, pin_memory=True, ) val_loader = DataLoader( datasets["valid"], batch_size=FLAGS["batch_size"] * 4, shuffle=False, num_workers=FLAGS["num_workers"], collate_fn=collate_fn, pin_memory=True, ) if model_ckpt is None: model = get_model(model_name, detector_name, FLAGS["trainable_layers"]) else: model = get_model(model_name, detector_name, FLAGS["trainable_layers"], model_ckpt) start_epoch = torch.load(model_ckpt)["epoch"] model.to(device) optimizer = Ranger( model.parameters(), lr=FLAGS["learning_rate"], alpha=0.5, k=6, N_sma_threshhold=5, weight_decay=FLAGS["weight_decay"], ) scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, "min", factor=0.75, verbose=True, patience=4) es = 0 scaler = GradScaler() for epoch in range(start_epoch, FLAGS["num_epochs"]): print("-" * 27 + f"Epoch #{epoch+1} started" + "-" * 27) train_loss = train_one_epoch( model, train_loader, optimizer, scaler, device, scheduler=None, log=log, ) print(f"Average loss for epoch #{epoch+1} : {train_loss}") val_metric = val_one_epoch(model, val_loader) scheduler.step(-val_metric) print(f"metric/val : {val_metric}") if log: neptune.log_metric("metric/val", val_metric) if (val_metric > best_score) or (best_score - val_metric < 0.01): es = 0 if val_metric > best_score: best_score = val_metric if epoch > 4: save_upload( model, optimizer, epoch, scheduler, val_metric, exp_name=FLAGS["exp_name"], ) else: es += 1 print("early stop counter: ", es) if es > 9 and epoch > 19: print("early stopping...") break print("-" * 28 + f"Epoch #{epoch+1} ended" + "-" * 28) neptune.stop()
import os import fast_fgvr_semi_train import neptune neptune.set_project('Serre-Lab/paleo-ai') os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' if __name__ == '__main__': #gpu_number = 3 num_trials = 1 username = '******' arg_db_name = 'validation_pnas' arg_net = 'resnet50_leaves_pretrained' arg_train_mode = 'hard' lr = '0.01' for idx in range(num_trials): args = [ '--gpu', '6', '--db_name', arg_db_name, '--net', arg_net, '--train_mode', arg_train_mode, '--margin', '0.1', '--batch_size','45', '--caffe_iter_size', '10', '--logging_threshold', '5', '--train_iters', '15000', '--test_interval','5', '--learning_rate', lr,
def __init__(self, tags, args): neptune.set_project('pixelneo/retrieval') neptune.create_experiment(params=args._data) for tag in tags: neptune.append_tag(tag)
def train_job(model_name, model_ckpt=None, log=True): exp_name = FLAGS['exp_name'] if log: neptune.set_project('utsav/wheat-det') neptune.init('utsav/wheat-det', api_token=NEPTUNE_API_TOKEN) neptune.create_experiment(FLAGS['exp_name'], exp_description, params=FLAGS, upload_source_files='*.txt') best_score = 0.0 start_epoch = 0 #sampler #fold_value_counts = train_df['folds'].value_counts() #fold_sample_counts = [value_counts.astype(np.float32) for value_counts in fold_value_counts] #num_samples = sum(fold_sample_counts) #class_weights = [num_samples/fold_sample_counts[i] for i in range(len(fold_sample_counts))] #weights = [class_weights[train_df['folds'].values[i]] for i in range(int(num_samples))] #sampler = WeightedRandomSampler(torch.DoubleTensor(weights), int(num_samples)) datasets = get_training_datasets() train_loader = DataLoader( datasets['train'], batch_size=FLAGS['batch_size'], num_workers=FLAGS['num_workers'], shuffle=True, #sampler=sampler, # collate_fn=collate_fn) val_loader = DataLoader(datasets['valid'], batch_size=FLAGS['batch_size'] * 2, shuffle=False, num_workers=FLAGS['num_workers'], collate_fn=collate_fn) if model_ckpt is not None: model = get_train_model(model_name, model_ckpt) else: model = get_train_model(model_name) model.to(device) optimizer = Ranger(model.parameters(), lr=FLAGS['learning_rate'], alpha=0.5, k=6, N_sma_threshhold=5, weight_decay=FLAGS['weight_decay']) scheduler = lr_scheduler.ReduceLROnPlateau(optimizer, 'min', factor=0.75, verbose=True, patience=FLAGS['scheduler_pat']) if model_ckpt is not None: checkpoint = torch.load(model_ckpt) scaler = GradScaler() es = 0 for epoch in range(start_epoch, FLAGS['num_epochs']): print('-' * 27 + f'Epoch #{epoch+1} started' + '-' * 27) train_loss = train_one_epoch(train_loader, model, optimizer, device, scaler, scheduler=None, log=log) print(f'Average loss for epoch #{epoch+1} : {train_loss}') val_metric, val_loss = val_one_epoch(model, val_loader) scheduler.step(val_loss) print(f'metric/val : {val_metric}') print(f'loss/val : {val_loss}') if log: neptune.log_metric('metric/val', val_metric) neptune.log_metric('loss/val', val_loss) #if epoch==FLAGS['unfreeze_epoch']: # model = unfreeze_all_layers(model) if (val_metric > best_score) or (best_score - val_metric < 0.01): es = 0 if (val_metric > best_score): best_score = val_metric if epoch > 9: save_upload(model, optimizer, epoch, scheduler, val_metric, exp_name=FLAGS['exp_name']) #else: # if epoch>24: # es+=1 #if es > FLAGS['early_stop_count']: # print('Early stopping...') # break print('-' * 28 + f'Epoch #{epoch+1} ended' + '-' * 28) neptune.stop()
params = return_params( path_name=args.path, att_lambda=args.attention_lambda, num_supervised_heads=args.num_supervised_heads, update_model_name=False, num_classes=None, ) params['best_params'] = True if args.num_supervised_heads: params['num_supervised_heads'] = args.num_supervised_heads if (params['logging'] == 'neptune'): assert args.project_name neptune.init(args.project_name, api_token=NEPTUNE_API_TOKEN) neptune.set_project(args.project_name) bert_model = None if (params['bert_tokens']): bert_model = params['path_files'] name_one = bert_model else: name_one = params['model_name'] name_one += "_" + datetime.now().strftime("%d/%m-%H:%M:%S") neptune.create_experiment(name_one, params=params, send_hardware_metrics=False, run_monitoring_thread=False) neptune.append_tag(name_one) if bert_model:
import skimage.io # Check versions import torch import numpy from platform import python_version print("python_version() ---> ", python_version()) print("torch.__version__ --> ", torch.__version__) # make sure to fix the randomness at the very beginning torch.manual_seed(0) numpy.random.seed(0) params = load_json_as_dict("./ML_parameters.json") neptune.set_project(params["neptune_project"]) exp: neptune.experiments.Experiment = \ neptune.create_experiment(params=flatten_dict(params), upload_source_files=["./main_smfish.py", "./ML_parameters.json", "./MODULES/vae_parts.py", "./MODULES/vae_model.py", "./MODULES/encoders_decoders.py"], upload_stdout=True, upload_stderr=True) # Get the training and test data preprocessed = load_obj("./data_train.pt") img_torch = preprocessed.img.float() roi_mask_torch = preprocessed.roi_mask.bool() assert len(img_torch.shape) == len(roi_mask_torch.shape) == 4 # print("GPU GB after opening data ->",torch.cuda.memory_allocated()/1E9) BATCH_SIZE = params["simulation"]["batch_size"]
# %% neptune_token = "eyJhcGlfYWRkcmVzcyI6Imh0dHBzOi8vdWkubmVwdHVuZS5haSIsImFwaV91cmwiOiJodHRwczovL3VpLm5lcHR1bmUuYWkiLCJhcGlfa2V5IjoiYTA2MTgwYjQtMGJkMS00MTcxLTk0MWEtZjIxZThmYjlhYTA5In0=" # %% train_batch_size = 1 # %% import neptune neptune.init( "haritz/srl-pred", api_token=neptune_token, ) neptune.set_project('haritz/srl-pred') PARAMS = { "num_epoch": epochs, 'lr': lr, 'pretrained_weights': pretrained_weights, 'loss_fn': 'crossentropy_label_smoothing', #'validation_size': len(validation_dataloader)*val_batch_size , 'random_seed': random_seed, 'total_steps': total_steps, 'training_size': len(train_dataloader) * train_batch_size, 'train_batch_size': train_batch_size, #'val_batch_size': val_batch_size, 'scheduler': 'get_linear_schedule_with_warmup' } PARAMS.update(dict_params)
#num_materials = len(dataset.product_id.unique()) num_materials = mergeddata_datasets.product_id.max() #shuffle here train = shuffle(train) #dataset.drop('index', axis=1, inplace=True) train.drop(columns=['customer_id', 'material']) test.drop(columns=['customer_id', 'material']) #train, test = train_test_split(dataset, test_size=0.2) #print (train.Head()) neptune.init(api_token="=", project_qualified_name="") neptune.set_project('') neptune.create_experiment(name='great-idea') class NeptuneMonitor(keras.callbacks.Callback): def on_epoch_end(self, epoch, logs=None): for metric_name, metric_value in logs.items(): neptune.log_metric(metric_name, metric_value) #Build the model print("Building model") latent_dim = 10 material_input = Input(shape=[1], name='material-input') customer_input = Input(shape=[1], name='customer-input')