def load_omniglot_image(root='dataset',n_validation=1345, state=123):
helpers.create(root, 'omniglot')
droot = root+'/'+'omniglot'
if not os.path.exists('{}/omniglot.amat'.format(droot)):
from downloader import download_omniglot
download_omniglot(droot)
def reshape_data(data):
return data.reshape((-1, 28, 28)).reshape((-1, 28*28), order='fortran')
path = '{}/omniglot.amat'.format(droot)
omni_raw = scipy.io.loadmat(path)
train_data = reshape_data(omni_raw['data'].T.astype(floatX))
test_data = reshape_data(omni_raw['testdata'].T.astype(floatX))
n = train_data.shape[0]
ind_va = np.random.RandomState(
state).choice(n, n_validation, replace=False)
ind_tr = np.delete(np.arange(n), ind_va)
return train_data[ind_tr], train_data[ind_va], test_data
def load_mnist_image(root='dataset',n_validation=1345, state=123):
helpers.create(root, 'bmnist')
droot = root+'/'+'bmnist'
if not os.path.exists('{}/train-images-idx3-ubyte'.format(droot)):
from downloader import download_bmnist
download_bmnist(droot)
path_tr = '{}/train-images-idx3-ubyte'.format(droot)
path_te = '{}/t10k-images-idx3-ubyte'.format(droot)
train_x = np.loadtxt(path_tr).astype(floatX)
test_x = np.loadtxt(path_te).astype(floatX)
return train_x[:50000], train_x[50000:], test_x
def load_caltech101_image(root='dataset'):
# binary
# tr: 4100 x 28 x 28
# va: 2264 x 28 x 28
# te: 2307 x 28 x 28
helpers.create(root, 'caltech101')
droot = root+'/'+'caltech101'
fn = 'caltech101_silhouettes_28_split1.mat'
if not os.path.exists('{}/{}'.format(droot, fn)):
from downloader import download_caltech101
download_caltech101(droot)
ds = scipy.io.loadmat('{}/{}'.format(droot, fn))
ds = [ds['train_data'], ds['val_data'], ds['test_data']]
return [d.astype(floatX) for d in ds]
def load_bmnist_image(root='dataset'):
helpers.create(root, 'bmnist')
droot = root + '/' + 'bmnist'
if not os.path.exists('{}/binarized_mnist_train.amat'.format(droot)):
from downloader import download_bmnist
download_bmnist(droot)
# Larochelle 2011
path_tr = '{}/binarized_mnist_train.amat'.format(droot)
path_va = '{}/binarized_mnist_valid.amat'.format(droot)
path_te = '{}/binarized_mnist_test.amat'.format(droot)
train_x = np.loadtxt(path_tr).astype(floatX).reshape(50000, 784)
valid_x = np.loadtxt(path_va).astype(floatX).reshape(10000, 784)
test_x = np.loadtxt(path_te).astype(floatX).reshape(10000, 784)
return train_x, valid_x, test_x
def load_cifar10_image(root='dataset',labels=False):
helpers.create(root, 'cifar10')
droot = root+'/'+'cifar10'
if not os.path.exists('{}/cifar10.pkl'.format(droot)):
from downloader import download_cifar10
download_cifar10(droot)
f = lambda d:d.astype(floatX)
filename = '{}/cifar10.pkl'.format(droot)
tr_x, tr_y, te_x, te_y = pickle.load(open(filename,'r'))
if tr_x.max() == 255:
tr_x = tr_x / 256.
te_x = te_x / 256.
if labels:
enc = OneHotEncoder(10)
tr_y = enc.fit_transform(tr_y).toarray().reshape(50000,10).astype(int)
te_y = enc.fit_transform(te_y).toarray().reshape(10000,10).astype(int)
return (f(d) for d in [tr_x, tr_y, te_x, te_y])
else:
return (f(d) for d in [tr_x, te_x])
import autoencoders as aes
from torch import optim, nn
from itertools import chain
import utils
import numpy as np
nmc = 3
lr1 = 0.0015
lr2 = 0.0003
batch_size = 20
zdim = 200
epoch = 10
print_every = 50
droot, sroot, spath = helpers.getpaths()
helpers.create(droot, 'mnist')
ds_transforms = transforms.Compose(
[transforms.ToTensor(), transforms_.binarize()])
train_loader = torch.utils.data.DataLoader(datasets.MNIST(
droot + '/mnist', download=True, train=True, transform=ds_transforms),
batch_size=batch_size,
shuffle=True)
enc = aes.BinaryLinear(784, zdim)
dec = aes.BinaryLinear(zdim, 784)
prior = aes.BinaryPrior(zdim)
iib = nn.parameter.Parameter(torch.zeros(1) - 200)
optim1 = optim.Adam(chain(dec.parameters(), prior.parameters(), [iib]),
def main(args, save_args=True, log_=True):
# create logger
helpers.create(*args.saveroot.split("/"))
logger = helpers.Logging(args.saveroot, "log.txt", log_)
logger.info(args)
# save args
if save_args:
with open(os.path.join(args.saveroot, "args.txt"), "w") as file:
file.write(json.dumps(args.__dict__, indent=4))
# dataset
logger.info(f"getting data: {args.data}")
ites, ate, w, t, y = get_data(args)
# comet logging
if args.comet:
exp = Experiment(project_name="causal-benchmark",
auto_metric_logging=False)
exp.add_tag(args.data)
logger.info(f"comet url: {exp.url}")
else:
exp = None
logger.info(f"ate: {ate}")
# distribution of outcome (y)
distribution = get_distribution(args)
logger.info(distribution)
# training params
training_params = TrainingParams(lr=args.lr,
batch_size=args.batch_size,
num_epochs=args.num_epochs)
logger.info(training_params.__dict__)
# initializing model
w_transform = preprocess.Preprocess.preps[args.w_transform]
y_transform = preprocess.Preprocess.preps[args.y_transform]
outcome_min = 0 if args.y_transform == "Normalize" else None
outcome_max = 1 if args.y_transform == "Normalize" else None
# model type
additional_args = dict()
if args.model_type == 'tarnet':
Model = TarNet
logger.info('model type: tarnet')
mlp_params = MLPParams(
n_hidden_layers=args.n_hidden_layers,
dim_h=args.dim_h,
activation=getattr(torch.nn, args.activation)(),
)
logger.info(mlp_params.__dict__)
network_params = dict(
mlp_params_w=mlp_params,
mlp_params_t_w=mlp_params,
mlp_params_y0_w=mlp_params,
mlp_params_y1_w=mlp_params,
)
elif args.model_type == 'linear':
Model = LinearModel
logger.info('model type: linear model')
network_params = dict()
elif 'gp' in args.model_type:
if args.model_type == 'gp':
Model = GPModel
elif args.model_type == 'targp':
Model = TarGPModel
else:
raise Exception(f'model type {args.model_type} not implemented')
logger.info('model type: linear model')
kernel_t = gpytorch.kernels.__dict__[args.kernel_t]()
kernel_y = gpytorch.kernels.__dict__[args.kernel_y]()
var_dist = gpytorch.variational.__dict__[args.var_dist]
network_params = dict(
gp_t_w=GPParams(kernel=kernel_t, var_dist=var_dist),
gp_y_tw=GPParams(kernel=kernel_y, var_dist=None),
)
logger.info(f'gp_t_w: {repr(network_params["gp_t_w"])}'
f'gp_y_tw: {repr(network_params["gp_y_tw"])}')
additional_args['num_tasks'] = args.num_tasks
else:
raise Exception(f'model type {args.model_type} not implemented')
if args.n_hidden_layers < 0:
raise Exception(
f'`n_hidden_layers` must be nonnegative, got {args.n_hidden_layers}'
)
model = Model(
w,
t,
y,
training_params=training_params,
network_params=network_params,
binary_treatment=True,
outcome_distribution=distribution,
outcome_min=outcome_min,
outcome_max=outcome_max,
train_prop=args.train_prop,
val_prop=args.val_prop,
test_prop=args.test_prop,
seed=args.seed,
early_stop=args.early_stop,
patience=args.patience,
ignore_w=args.ignore_w,
grad_norm=args.grad_norm,
w_transform=w_transform,
y_transform=y_transform, # TODO set more args
savepath=os.path.join(args.saveroot, 'model.pt'),
test_size=args.test_size,
additional_args=additional_args)
# TODO GPU support
if args.train:
model.train(print_=logger.info, comet_exp=exp)
# evaluation
if args.eval:
summary, all_runs = evaluate(args, model)
logger.info(summary)
with open(os.path.join(args.saveroot, "summary.txt"), "w") as file:
file.write(json.dumps(summary, indent=4))
with open(os.path.join(args.saveroot, "all_runs.txt"), "w") as file:
file.write(json.dumps(all_runs))
model.plot_ty_dists()
return model
