def main():
#hparams = [(low, high), #per var
# (low, high)]
hparams = [
(0, 20), #positive_reward_for_divert
(0, 20), #wrong_sup_at_goal
(0, 20), #flooding_reward
(0, 20), #neg_reward_ia
(0, 20), #negative_reward_for_empty_queue
(0, 20)
] #negative_reward_for_cycle
#define path for the results
hyperdive_results = join(path, 'rl', 'hyper_parameter', env_name)
#make folder if not exist
try:
os.mkdir(hyperdive_results)
except:
pass
#run the hyper drive optimization
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=hyperdive_results,
checkpoints_path=hyperdive_results,
model="GP",
n_iterations=50,
verbose=True,
random_state=42)
def run(results_dir, n_calls=200, n_runs=10):
"""Run benchmark for Branin function."""
models = ['GP', 'RF', 'GBRT', 'Rand']
bounds = [(-5.0, 10.0), (0.0, 15.0)]
for model in models:
model_dir = os.path.join(results_dir, model)
if not os.path.exists(model_dir):
os.makedirs(model_dir, exist_ok=True)
for random_state in range(n_runs):
directory = os.path.join(model_dir, 'run' + str(random_state))
if not os.path.exists(directory):
os.makedirs(directory, exist_ok=True)
checkpoint = load_results(directory)
hyperdrive(branin,
bounds,
directory,
n_iterations=n_calls,
verbose=True,
random_state=random_state,
checkpoints=True,
restart=checkpoint)
def run(results_dir, n_calls=200, n_runs=10):
"""Run benchmark for Branin function."""
models = ['Rand']
bounds = np.tile((-5., 5.), (4, 1))
for model in models:
model_dir = os.path.join(results_dir, model)
if not os.path.exists(model_dir):
os.makedirs(model_dir, exist_ok=True)
for random_state in range(n_runs):
directory = os.path.join(model_dir, 'run' + str(random_state))
if not os.path.exists(directory):
os.makedirs(directory, exist_ok=True)
# checkpoint = load_results(directory)
hyperdrive(stybtang,
bounds,
directory,
n_iterations=n_calls,
verbose=True,
random_state=random_state,
checkpoints=True)
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument('--results_dir', type=str, help='Path to results directory.')
parser.add_argument('--log_dir', type=str, default='./logs', help='Path to save logs')
args = parser.parse_args()
# Logging for Visual Comparison
global logger
log_cols=["Classifier", "Train Accuracy", "Val Accuracy", "Log Loss"]
logger = Log(colnames=log_cols, savepath=args.log_dir, rank=rank)
global X_train; global X_val; global X_test; global y_train; global y_val; global y_test
X_train, X_val, X_test, y_train, y_val, y_test = load_data(0.25, 0.25)
hparams = [(25, 100), # n_estimators
(2, 10)] # max_depth
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=50,
verbose=True,
random_state=0,
checkpoints=True)
# Save the log data frame
logger.save()
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument('--results_dir',
type=str,
help='Path to results directory.')
args = parser.parse_args()
hparams = [
(2, 10), # max_depth
(10.0**-2, 10.0**0), # learning_rate
(1, 10), # max_features
(2, 100), # min_samples_split
(1, 100)
] # min_samples_leaf
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=50,
verbose=True,
random_state=0,
sampler="lhs",
n_samples=5,
checkpoints=True)
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument('--results_dir',
type=str,
help='Path to results directory.')
args = parser.parse_args()
global batch_size, num_classes, epochs
batch_size = 128
num_classes = 10
epochs = 12
# input image dimensions
img_rows, img_cols = 28, 28
global x_train, y_train, x_test, y_test
# the data, split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
global input_shape
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
# convert class vectors to binary class matrices
y_train = keras.utils.to_categorical(y_train, num_classes)
y_test = keras.utils.to_categorical(y_test, num_classes)
hparams = [
(2, 5), # kernel1
(2, 5), # kernel2
(0.25, 0.75), # dropout1
(0.25, 0.75)
] # dropout2
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=20,
verbose=True,
random_state=0)
def main():
parser = argparse.ArgumentParser(description='CHEERS hyperparameter optimization')
parser.add_argument('--results', type=str, help='Path to results directory.')
args = parser.parse_args()
hparams = [(0.1, 1000), # C
(0.0001, 10)] # epsilon
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results,
checkpoints_path=args.results,
model="GP",
n_iterations=100,
verbose=True,
random_state=0)
def main():
global args
args = parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
train_data = Deidentified(
data_path=args.data_dir + '/data/train',
label_path=args.data_dir + '/labels/train'
)
global train_size
train_size = len(train_data)
test_data = Deidentified(
data_path=args.data_dir + '/data/test',
label_path=args.data_dir + '/labels/test'
)
global train_loader
train_loader = DataLoader(train_data, batch_size=args.batch_size, shuffle=True)
global test_loader
test_loader = DataLoader(test_data, batch_size=args.batch_size, shuffle=False)
global wv_matrix
wv_matrix = load_wv_matrix(args.data_dir + '/wv_matrix/wv_matrix.npy')
global criterion
criterion = nn.CrossEntropyLoss()
hparams = [(2, 10), # kernel1
(2, 10), # kernel2
(2, 10), # kernel3
(100, 200), # num_filters1
(100, 200), # num_filters2
(100, 200)] # num_filters3
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=15,
verbose=True,
random_state=0)
def main():
hparams = [
(2, 10), # encoder kernel1
(2, 10), # encoder kernel2
(2, 10), # encoder kernel3
(2, 10), # decoder kernel1
(2, 10), # decoder kernel2
(2, 10)
] # decoder kernel3
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=50,
verbose=True,
random_state=0,
deadline=args.deadline)
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument('--results_dir', type=str, help='Path to results directory.')
args = parser.parse_args()
hparams = [(2, 10), # max_depth
(10.0**-2, 10.0**0)] # learning_rate
# Load results from previous runs
checkpoint = load_results(args.results_dir)
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=100,
verbose=True,
random_state=0,
checkpoints=True,
restart=checkpoint)
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument('--results_dir', type=str, help='Path to results directory.')
args = parser.parse_args()
hparams = [(0.001, 0.1),
(0.0, 0.90),
(0.001, 0.1),
(0.0, 0.90)]
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=15,
verbose=True,
random_state=0,
sampler="lhs",
n_samples=5,
checkpoints=True)
def main():
hparams = [
(2, 10), # kernel1
(2, 10), # kernel2
(2, 10), # kernel3
(2, 10), # kernel4
(0.25, 0.95), # dropout5
(0.25, 0.95)
] # dropout6
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=20,
verbose=True,
sampler="lhs",
n_samples=4,
random_state=0,
deadline=args.deadline)
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument('--results_dir',
type=str,
help='Path to results directory.')
args = parser.parse_args()
hparams = [
(2, 10), # max_depth
(10.0**-2, 10.0**0)
] # learning_rate
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=100,
verbose=True,
random_state=0,
deadline=120)
def main():
global args
args = parse_args()
torch.manual_seed(args.seed)
global device
device = torch.device("cuda" if args.cuda else "cpu")
global corpus
corpus = data.Corpus(args.data)
global eval_batch_size
eval_batch_size = 10
global train_data
train_data = batchify(corpus.train, args.batch_size)
global val_data
val_data = batchify(corpus.valid, eval_batch_size)
global criterion
criterion = nn.CrossEntropyLoss()
hparams = [
(2, 5), # nlayers
(100, 300), # word embedding dim
(50, 250), # nhid
('RNN_TANH', 'RNN_RELU', 'LSTM', 'GRU') # model
]
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=20,
verbose=True,
random_state=0,
deadline=7000,
checkpoints=True)
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument(
'--ndims',
type=int,
help='Number of dimensions for Styblinski-Tang function')
parser.add_argument('--results_dir',
type=str,
help='Path to results directory.')
parser.add_argument('--checkpoints', type=str, help='Path to checkpoints')
args = parser.parse_args()
stybtang = StyblinskiTang(args.ndims)
bounds = np.tile((-5., 5.), (args.ndims, 1))
hyperdrive(objective=stybtang,
hyperparameters=bounds,
results_path=args.results_dir,
checkpoints_path=args.checkpoints,
model="GP",
n_iterations=50,
verbose=True,
random_state=0)
def main():
hparams = [
(2, 10), # kernel1
(2, 10), # kernel2
(2, 10), # kernel3
(2, 10), # kernel4
(2, 10), # kernel5
(2, 10), # kernel6
(2, 10), # kernel7
(2, 10), # kernel8
(2, 10), # kernel9
(2, 10), # kernel10
(0.25, 0.95), # dropout5
(0.25, 0.95)
] # dropout6
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=50,
verbose=True,
random_state=0,
deadline=args.deadline)
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument('--results_dir',
type=str,
help='Path to results directory.')
args = parser.parse_args()
hparams = [
(2, 8), # kernel1
(2, 8)
] # kernel2
# (2, 8), # kernel3
# (2, 8), # kernel4
# (2, 8), # kernel5
# (2, 8), # kernel6
# (32, 64)] # batch_size
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=11,
verbose=True,
random_state=0)
[True, False], # use cyclic
(0, 8), # nheads
(64, 1024), # itnermedioate
(1, 6)
] # linear layers
try:
os.makedirs(
'/gpfs/alpine/med106/proj-shared/aclyde/MolecularAttention/qm8/hyperopt/cv'
+ str(config['cv']) + '/results/')
except:
pass
try:
os.makedirs(
'/gpfs/alpine/med106/proj-shared/aclyde/MolecularAttention/qm8/hyperopt/cv'
+ str(config['cv']) + '/checkpoints/')
except:
pass
hyperdrive(
objective=train_qm8,
hyperparameters=params,
results_path=
'/gpfs/alpine/med106/proj-shared/aclyde/MolecularAttention/qm8/hyperopt/cv'
+ str(config['cv']) + '/results/',
checkpoints_path=
'/gpfs/alpine/med106/proj-shared/aclyde/MolecularAttention/qm8/hyperopt/cv'
+ str(config['cv']) + '/checkpoints/',
model="GP",
n_iterations=50,
verbose=True,
random_state=0)
def main():
parser = argparse.ArgumentParser(description='Setup experiment.')
parser.add_argument('--results_dir',
type=str,
default='./results',
help='Path to results directory.')
parser.add_argument('--log_dir',
type=str,
default='./logs',
help='Path to save logs')
parser.add_argument(
'--data',
type=str,
default='/lustre/atlas/proj-shared/csc249/yngtodd/data/fashion',
help='Path to data')
args = parser.parse_args()
# k-fold configuration
n_splits = 2
# get data
trainpath = os.path.join(args.data, 'fashion-mnist_train.csv')
testpath = os.path.join(args.data, 'fashion-mnist_test.csv')
test = pd.read_csv(trainpath)
train = pd.read_csv(testpath)
global logger
log_cols = ["Classifier", "Train Accuracy (Mean)", "Val Accuracy", "Loss"]
logger = Log(colnames=log_cols, savepath=args.log_dir, rank=rank)
global y_train_CNN, X_train_CNN
y_train_CNN = train.ix[:, 0].values.astype(
'int32') # only labels i.e targets digits
X_train_CNN = np.array(train.iloc[:, 1:].values).reshape(
train.shape[0], 1, 28,
28).astype(np.uint8) # reshape to be [samples][pixels][width][height]
global y_test_CNN, X_test_CNN
y_test_CNN = test.ix[:, 0].values.astype(
'int32') # only labels i.e targets digits
X_test_CNN = np.array(test.iloc[:, 1:].values).reshape(
(test.shape[0], 1, 28, 28)).astype(np.uint8)
# normalize inputs from 0-255 to 0-1
X_train_CNN = X_train_CNN / 255
X_test_CNN = X_test_CNN / 255
global X_train, X_val, y_train, y_val
X_train, X_val, y_train, y_val = \
train_test_split(X_train_CNN, y_train_CNN, test_size=0.33, random_state=42)
# one hot encode outputs
y_train = to_categorical(y_train)
y_val = to_categorical(y_val)
y_test = to_categorical(y_test_CNN)
num_classes = y_train.shape[1]
global kf
kf = KFold(n_splits=n_splits, random_state=seed, shuffle=True)
kf.get_n_splits(X_train)
hparams = [(0.0001, 0.1) # lr
]
hyperdrive(objective=objective,
hyperparameters=hparams,
results_path=args.results_dir,
model="GP",
n_iterations=100,
verbose=True,
random_state=0,
checkpoints=True)
# Save the log data frame
logger.save()
def main():
# Training settings
parser = argparse.ArgumentParser(description='PyTorch MNIST Example')
parser.add_argument('--batch-size', type=int, default=64, metavar='N',
help='input batch size for training (default: 64)')
parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N',
help='input batch size for testing (default: 1000)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--momentum', type=float, default=0.5, metavar='M',
help='SGD momentum (default: 0.5)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
parser.add_argument('--seed', type=int, default=42, metavar='S',
help='random seed (default: 42)')
parser.add_argument('--log-interval', type=int, default=10, metavar='N',
help='how many batches to wait before logging training status')
parser.add_argument('--fp16-allreduce', action='store_true', default=False,
help='use fp16 compression during allreduce')
parser.add_argument('--results_path', type=str, help="Path to store results")
args = parser.parse_args()
args.cuda = not args.no_cuda and torch.cuda.is_available()
# Horovod: initialize library.
hvd.init()
torch.manual_seed(args.seed)
if args.cuda:
# Horovod: pin GPU to local rank.
torch.cuda.set_device(hvd.local_rank())
torch.cuda.manual_seed(args.seed)
kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}
train_dataset = \
datasets.MNIST('data-%d' % hvd.rank(), train=True, download=True,
transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
# Horovod: use DistributedSampler to partition the training data.
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset, num_replicas=hvd.size(), rank=hvd.rank())
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, sampler=train_sampler, **kwargs)
test_dataset = \
datasets.MNIST('data-%d' % hvd.rank(), train=False, transform=transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307,), (0.3081,))
]))
# Horovod: use DistributedSampler to partition the test data.
test_sampler = torch.utils.data.distributed.DistributedSampler(
test_dataset, num_replicas=hvd.size(), rank=hvd.rank())
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=args.test_batch_size,
sampler=test_sampler, **kwargs)
model = Net()
if args.cuda:
# Move model to GPU.
model.cuda()
# Horovod: broadcast parameters.
hvd.broadcast_parameters(model.state_dict(), root_rank=0)
global optimizer
# Horovod: scale learning rate by the number of GPUs.
optimizer = optim.SGD(model.parameters(), lr=args.lr * hvd.size(),
momentum=args.momentum)
# Horovod: (optional) compression algorithm.
compression = hvd.Compression.fp16 if args.fp16_allreduce else hvd.Compression.none
# Horovod: wrap optimizer with DistributedOptimizer.
optimizer = hvd.DistributedOptimizer(optimizer,
named_parameters=model.named_parameters(),
compression=compression)
#for epoch in range(1, args.epochs + 1):
# train(epoch, model, optimizer, train_sampler, train_loader, args)
# test(model, test_sampler, test_loader, args)
space = [(2, 8)]
#if hvd.rank() == 0:
hyperdrive(
lambda hparams: objective(
hparams,
model,
train_sampler,
train_loader,
args
),
hyperparameters=space,
results_path=args.results_path,
checkpoints_path=args.results_path,
model="GP",
n_iterations=50,
verbose=True,
random_state=0
)
def main():
global train_x
global train_y
global test_x
global test_y
train_x = np.load('data/train_X.npy')
train_y = np.load('data/train_Y.npy')
test_x = np.load('data/test_X.npy')
test_y = np.load('data/test_Y.npy')
for task in range(4):
le = preprocessing.LabelEncoder()
le.fit(train_y[:, task])
train_y[:, task] = le.transform(train_y[:, task])
test_y[:, task] = le.transform(test_y[:, task])
max_vocab = np.max(train_x)
max_vocab2 = np.max(test_x)
if max_vocab2 > max_vocab:
max_vocab = max_vocab2
print('max_vocab:', max_vocab)
np.random.seed(0)
global wv_len
wv_len = 50
global wv_mat
wv_mat = np.random.randn(max_vocab + 1, wv_len).astype('float32') * 0.1
#num_classes = np.max( train_y ) + 1
global num_classes
num_classes = []
num_classes.append(np.max(train_y[:, 0]) + 1)
num_classes.append(np.max(train_y[:, 1]) + 1)
num_classes.append(np.max(train_y[:, 2]) + 1)
num_classes.append(np.max(train_y[:, 3]) + 1)
global validation_data
validation_data = ({
'Input': test_x
}, {
'Dense0': test_y[:, 0],
'Dense1': test_y[:, 1],
'Dense2': test_y[:, 2],
'Dense3': test_y[:, 3]
})
space = [(1, 10), (1, 10), (1, 10), (5, 500), (0.00001, 0.1)]
savepoint = load_results(args.results_dir)
hyperdrive(objective=objective,
hyperparameters=space,
results_path=args.results_dir,
model="GP",
n_iterations=25,
checkpoints=True,
verbose=True,
random_state=0,
restart=savepoint)
