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)