Example #1
0
    def calculate(self, training_file):
        """
        Since GP standardizes both inputs and outputs, we do that here as well
        """
        #Assumes the training data is of [X,Y]
        train = np.loadtxt(training_file)
        train_x = train[:, :self.mean_var[0]]
        train_y = train[:, self.mean_var[0]:]

        #####################################################
        #Step 1: standardize X AND Y                        #
        #####################################################
        X_0 = torch.as_tensor(self.DR_func.Scale(train_x))
        train_y = torch.as_tensor(train_y)

        #####################################################
        #Step 5: Train on training data                     #
        #####################################################
        #use batching
        if len(X_0) * .1 >= 2:
            num_batch = min(2**int(math.log(len(X_0) * .1, 2)), 256)
        else:
            num_batch = len(X_0)
        dataset = NN.Data(X_0, torch.as_tensor(train_y))
        train_loader = DataLoader(dataset=dataset,
                                  batch_size=num_batch,
                                  shuffle=True)

        self.mean_func.train()
        for epochs in range(self.mean_var[-1]):
            for batch_idx, (inputs, labels) in enumerate(train_loader):
                self.mean_func.optimiser.zero_grad()
                #get estimate of y from DR
                y_hat = self.mean_func(inputs)
                #calc loss
                loss = self.mean_func.error_function(labels, y_hat)
                loss.backward()
                self.mean_func.optimiser.step()
                if (batch_idx == 0 and epochs % 100 == 0):
                    print("loss: %s" % (loss.item()))

        self.mean_func.eval()
        return print('NN model created')
Example #2
0
    def calculate(self, train_x, train_y):
        ###assumes train_x or train_y is not standardized
        """
        NN works best with normalized values
        """
        dim_in = self.NN_var[0]
        #####################################################
        #Step 1: normalize X                                #
        #####################################################

        X_0 = torch.as_tensor(self.Scale(train_x))
        self.norm_range = np.c_[np.zeros(dim_in), np.ones(dim_in)]

        #####################################################
        #Step 2: Set seed for consistent results            #
        #####################################################

        torch.random.manual_seed(self.seed_value)

        #####################################################
        #Step 3: create Model                               #
        #####################################################

        self.Model = NN.DR_Network(self.dim_DR, self.NN_var)

        #####################################################
        #Step 4: Train on training data                     #
        #####################################################
        #use batching
        if len(X_0) * .1 >= 2:
            num_batch = min(2**int(math.log(len(X_0) * .1, 2)), 256)
        else:
            num_batch = len(X_0)
        dataset = NN.Data(X_0, torch.as_tensor(train_y))
        train_loader = DataLoader(dataset=dataset,
                                  batch_size=num_batch,
                                  shuffle=True)

        self.Model.train()
        for epochs in range(self.NN_var[-3]):
            for batch_idx, (inputs, labels) in enumerate(train_loader):
                self.Model.optimiser.zero_grad()
                #get estimate of y from DR
                _, y_hat, x_hat = self.Model(inputs)
                #calc loss
                loss = self.Model.error_function(x_hat, y_hat, inputs, labels,
                                                 self.norm_range[:, 0],
                                                 self.norm_range[:, 1],
                                                 self.NN_var[-2],
                                                 self.NN_var[-1])
                #error function(x estimate, y estimate, true normalized x, true y, xlb, xub, lam, P)
                loss.backward()
                self.Model.optimiser.step()
                if (batch_idx == 0 and epochs % 100 == 0):
                    print("loss: %s" % (loss.item()))

        self.Model.eval()
        self.DR_range = self.Model.DR_range
        #self.DR_range=np.c_[self.Model.min_val.detach().numpy()*np.ones(self.dim_DR),self.Model.max_val.detach().numpy()*np.ones(self.dim_DR)]

        return print('NN model created')