def fit(self, X, y):
"""
Pytorch simple regressor to estimate the mu of a gaussian,
we estimate the sigma over the training set.
"""
self.model = PytorchReg(X.shape[1])
dataset = torch.utils.data.TensorDataset(torch.Tensor(X),
torch.Tensor(y))
optimizer = optim.Adam(self.model.parameters(), lr=4e-3)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
factor=0.1,
patience=30,
verbose=True)
self.model, _ = train(self.model,
dataset,
validation_fraction=validation_fraction,
return_best_model=True,
optimizer=optimizer,
scheduler=scheduler,
n_epochs=n_epochs,
batch_size=batch_size,
loss_fn=nn.MSELoss(),
disable_cuda=True)
def fit(self, X_in, y_in):
self.model = SimpleBinnedNoBounds(N_GAUSSIANS, X_in.shape[1])
dataset = torch.utils.data.TensorDataset(torch.Tensor(X_in),
torch.Tensor(y_in))
optimizer = optim.Adam(self.model.parameters(), lr=LR, amsgrad=True)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
factor=0.1,
patience=20,
cooldown=20,
min_lr=1e-7,
verbose=True)
loss = CustomLoss()
self.model, _ = train(self.model,
dataset,
validation_fraction=VALIDATION_FRACTION,
optimizer=optimizer,
scheduler=scheduler,
n_epochs=n_epochs,
batch_size=BATCH_SIZE,
loss_fn=loss,
return_best_model=True,
disable_cuda=True,
drop_last=True)
def test_batch_predict():
# Batch predict is equal to non batch predict
# create a simple model (a MLP with 2 inner layers)
device = _set_device()
input_size, output_size, layers = 2, 2, [5, 5]
model = MLP(input_size, output_size, layers)
model = model.to(device)
# create a random dataset. take a number of samples that is not a multiple
# of the batch_size.
n_samples = 26
x = torch.randn(n_samples, input_size)
y = torch.randn(n_samples, output_size)
dataset = data.TensorDataset(x, y)
model = train(model, dataset, n_epochs=1, batch_size=10)
with torch.no_grad():
predictions_without_batch = model(x.to(device)).cpu()
predictions_with_batch = predict(model, x, batch_size=10)
predictions_with_predict_no_batch = predict(model, x, batch_size=None)
assert_almost_equal(predictions_with_batch.numpy(),
predictions_without_batch.numpy())
assert_almost_equal(predictions_with_batch.numpy(),
predictions_with_predict_no_batch.numpy())
def fit(self, X_in, y_in):
# standardize features
self.std = StandardScaler().fit(X_in)
X_in = self.std.transform(X_in)
self.scaler_y.fit(y_in)
y_in = self.scaler_y.transform(y_in)
self.model = VAE(y_in.shape[1], X_in.shape[1])
dataset = torch.utils.data.TensorDataset(torch.Tensor(X_in),
torch.Tensor(y_in))
optimizer = optim.Adam(self.model.parameters(),
lr=LR,
weight_decay=DECAY,
amsgrad=True)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
factor=0.1,
patience=30,
cooldown=20,
min_lr=1e-7,
verbose=True)
loss = CustomLoss()
self.model, _ = train(self.model,
dataset,
validation_fraction=VAL_SIZE,
optimizer=optimizer,
scheduler=scheduler,
n_epochs=n_epochs,
batch_size=BATCH_SIZE,
loss_fn=loss,
return_best_model="Loss",
disable_cuda=True,
drop_last=True,
is_vae=True)
def fit(self, X, y):
"""
Pytorch simple regressor to estimate the mu of a gaussian,
we estimate the sigma over the training set.
"""
self.model = PytorchReg(X.shape[1])
dataset = torch.utils.data.TensorDataset(torch.Tensor(X),
torch.Tensor(y))
optimizer = optim.Adam(self.model.parameters(), lr=4e-3)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
factor=0.1,
patience=30,
verbose=True)
self.model, _ = train(self.model,
dataset,
validation_fraction=validation_fraction,
return_best_model=True,
optimizer=optimizer,
scheduler=scheduler,
n_epochs=n_epochs,
batch_size=batch_size,
loss_fn=nn.MSELoss(),
disable_cuda=True)
# we run our model over the whole training data to get an estimate
# of sigma from the residual variance
self.model.eval()
with torch.no_grad():
X = torch.Tensor(X)
y_guess = self.model(X).detach().numpy()
error = (y - y_guess).ravel()
self.sigma = np.sqrt((1 / (X.shape[0] - 1)) * np.sum(error**2))
def fit(self, X_in, y_in):
# standardize features
self.std = StandardScaler().fit(X_in)
X_in = self.std.transform(X_in)
self.scaler_y.fit(y_in)
y_in = self.scaler_y.transform(y_in)
mask = torch.arange(0, y_in.shape[1]) % 2
mask = mask.to(device).float()
modules = []
for _ in range(N_BLOCKS):
modules += [
CouplingLayer(y_in.shape[1],
LAYER_SIZE,
mask,
X_in.shape[1],
s_act='tanh',
t_act='relu'),
BatchNormFlow(y_in.shape[1])
]
mask = 1 - mask
self.model = FlowSequential(*modules)
dataset = torch.utils.data.TensorDataset(torch.Tensor(X_in),
torch.Tensor(y_in))
optimizer = optim.Adam(self.model.parameters(),
lr=LR,
weight_decay=DECAY,
amsgrad=True)
scheduler = optim.lr_scheduler.ReduceLROnPlateau(optimizer,
'min',
factor=0.1,
patience=20,
cooldown=10,
min_lr=1e-7,
verbose=True)
loss = self.model.log_probs
self.model = train(self.model,
dataset,
validation_fraction=VAL_SIZE,
optimizer=optimizer,
scheduler=scheduler,
n_epochs=n_epochs,
batch_size=BATCH_SIZE,
loss_fn=loss,
disable_cuda=True,
drop_last=True,
is_nvp=True)
def test_best_model():
# check the best model
loss_fn = torch.nn.MSELoss()
# create a simple model (a MLP with 2 inner layers)
device = _set_device()
input_size, output_size, layers = 2, 2, [50, 50]
model = MLP(input_size, output_size, layers)
model = model.to(device)
# create a random dataset
n_samples = 100
x = torch.randn(n_samples, input_size)
y = 2 * x + 1
x, y = x.to(device), y.to(device)
dataset = data.TensorDataset(x, y)
# create training and validation sets
validation_fraction = 0.5
n_samples = len(dataset)
ind_split = int(np.floor(validation_fraction * n_samples))
dataset_train = data.TensorDataset(*dataset[ind_split:])
dataset_valid = data.TensorDataset(*dataset[:ind_split])
optimizer = optim.Adam(model.parameters(), lr=1e-2)
model, best_val_loss = train(model,
dataset_train,
optimizer=optimizer,
dataset_valid=dataset_valid,
n_epochs=10,
batch_size=20,
return_best_model=True,
loss_fn=loss_fn)
# check val_loss
X_valid = dataset_valid.tensors[0]
y_valid = dataset_valid.tensors[1]
y_valid_pred = predict(model, X_valid)
val_loss = loss_fn(y_valid, y_valid_pred).item()
assert_almost_equal(val_loss, best_val_loss)
