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')
