pcntoolkit 0.32.0__py3-none-any.whl

pcntoolkit/normative_model/norm_np.py

@@ -0,0 +1,333 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri Nov 22 14:41:07 2019
+
+@author: seykia
+"""
+
+from __future__ import print_function
+from __future__ import division
+
+import os
+import sys
+import numpy as np
+import torch
+from torch import nn, optim
+from torch.nn import functional as F
+from sklearn.linear_model import LinearRegression
+from sklearn.preprocessing import MinMaxScaler
+import pickle
+
+try:  # run as a package if installed
+    from pcntoolkit.normative_model.normbase import NormBase
+    from pcntoolkit.model.NPR import NPR, np_loss
+except ImportError:
+    pass
+
+    path = os.path.abspath(os.path.dirname(__file__))
+    if path not in sys.path:
+        sys.path.append(path)
+    del path
+
+    from model.NPR import NPR, np_loss
+    from norm_base import NormBase
+
+
+class struct(object):
+    pass
+
+
+class Encoder(nn.Module):
+    """
+    Encoder module for the Neural Process Regression model.
+
+    This module is responsible for encoding the input data into a latent representation. 
+    It is a part of the Neural Process Regression (NPR) model and is implemented as a PyTorch module.
+
+    :param x: Input data matrix.
+    :param y: Target values.
+    :param args: A dictionary-like object containing the following attributes:
+        - r_dim: Dimension of the latent representation.
+        - z_dim: Dimension of the latent variable.
+        - hidden_neuron_num: Number of neurons in the hidden layers.
+    """
+
+    def __init__(self, x, y, args):
+        """
+        Initialize the Encoder module.
+
+        :param x: Input data matrix.
+        :param y: Target values.
+        :param args: A dictionary-like object containing the following attributes:
+            - r_dim: Dimension of the latent representation.
+            - z_dim: Dimension of the latent variable.
+            - hidden_neuron_num: Number of neurons in the hidden layers.
+        """
+        super(Encoder, self).__init__()
+        self.r_dim = args.r_dim
+        self.z_dim = args.z_dim
+        self.hidden_neuron_num = args.hidden_neuron_num
+        self.h_1 = nn.Linear(x.shape[1] + y.shape[1], self.hidden_neuron_num)
+        self.h_2 = nn.Linear(self.hidden_neuron_num, self.hidden_neuron_num)
+        self.h_3 = nn.Linear(self.hidden_neuron_num, self.r_dim)
+
+    def forward(self, x, y):
+        """
+        Forward pass of the Encoder module.
+
+        :param x: Input data matrix.
+        :param y: Target values.
+        :return: The latent representation of the input data.
+        """
+
+        x_y = torch.cat([x, y], dim=2)
+        x_y = F.relu(self.h_1(x_y))
+        x_y = F.relu(self.h_2(x_y))
+        x_y = F.relu(self.h_3(x_y))
+        r = torch.mean(x_y, dim=1)
+        return r
+
+
+class Decoder(nn.Module):
+    """
+    Decoder module for the Neural Process Regression model.
+
+    This module is responsible for decoding the latent representation into the target values. 
+    It is a part of the Neural Process Regression (NPR) model and is implemented as a PyTorch module.
+
+    :param x: Input data matrix.
+    :param y: Target values.
+    :param args: A dictionary-like object containing the following attributes:
+        - r_dim: Dimension of the latent representation.
+        - z_dim: Dimension of the latent variable.
+        - hidden_neuron_num: Number of neurons in the hidden layers.
+    """
+
+    def __init__(self, x, y, args):
+        """
+        Initialize the Decoder module.
+
+        :param x: Input data matrix.
+        :param y: Target values.
+        :param args: A dictionary-like object containing the following attributes:
+            - r_dim: Dimension of the latent representation.
+            - z_dim: Dimension of the latent variable.
+            - hidden_neuron_num: Number of neurons in the hidden layers.
+        """
+        super(Decoder, self).__init__()
+        self.r_dim = args.r_dim
+        self.z_dim = args.z_dim
+        self.hidden_neuron_num = args.hidden_neuron_num
+
+        self.g_1 = nn.Linear(self.z_dim, self.hidden_neuron_num)
+        self.g_2 = nn.Linear(self.hidden_neuron_num, self.hidden_neuron_num)
+        self.g_3 = nn.Linear(self.hidden_neuron_num, y.shape[1])
+
+        self.g_1_84 = nn.Linear(self.z_dim, self.hidden_neuron_num)
+        self.g_2_84 = nn.Linear(self.hidden_neuron_num, self.hidden_neuron_num)
+        self.g_3_84 = nn.Linear(self.hidden_neuron_num, y.shape[1])
+
+    def forward(self, z_sample):
+        """
+        Forward pass of the Decoder module.
+
+        :param z_sample: Sampled latent variable.
+        :return: The predicted target values.
+        """
+        z_hat = F.relu(self.g_1(z_sample))
+        z_hat = F.relu(self.g_2(z_hat))
+        y_hat = torch.sigmoid(self.g_3(z_hat))
+
+        z_hat_84 = F.relu(self.g_1(z_sample))
+        z_hat_84 = F.relu(self.g_2_84(z_hat_84))
+        y_hat_84 = torch.sigmoid(self.g_3_84(z_hat_84))
+
+        return y_hat, y_hat_84
+
+
+class NormNP(NormBase):
+    """ Classical GPR-based normative modelling approach
+    """
+
+    def __init__(self, X, y, configparam=None):
+        """
+        Initialize the NormNP object.
+
+        This function initializes the NormNP object with the given arguments. It requires a data matrix 'X' and target 'y'. 
+        It also takes an optional 'configparam' which is a path to a pickle file containing configuration parameters. 
+        If 'configparam' is not provided, default values are used for the configuration parameters.
+
+        :param X: Data matrix.
+        :param y: Target values.
+        :param configparam: Path to a pickle file containing configuration parameters. Optional.
+        """
+        self.configparam = configparam
+        if configparam is not None:
+            with open(configparam, 'rb') as handle:
+                config = pickle.load(handle)
+            args = struct()
+            if 'batch_size' in config:
+                args.batch_size = config['batch_size']
+            else:
+                args.batch_size = 10
+            if 'epochs' in config:
+                args.epochs = config['epochs']
+            else:
+                args.epochs = 100
+            if 'device' in config:
+                args.device = config['device']
+            else:
+                args.device = torch.device('cpu')
+            if 'm' in config:
+                args.m = config['m']
+            else:
+                args.m = 200
+            if 'hidden_neuron_num' in config:
+                args.hidden_neuron_num = config['hidden_neuron_num']
+            else:
+                args.hidden_neuron_num = 10
+            if 'r_dim' in config:
+                args.r_dim = config['r_dim']
+            else:
+                args.r_dim = 5
+            if 'z_dim' in config:
+                args.z_dim = config['z_dim']
+            else:
+                args.z_dim = 3
+            if 'nv' in config:
+                args.nv = config['nv']
+            else:
+                args.nv = 0.01
+        else:
+            args = struct()
+            args.batch_size = 10
+            args.epochs = 100
+            args.device = torch.device('cpu')
+            args.m = 200
+            args.hidden_neuron_num = 10
+            args.r_dim = 5
+            args.z_dim = 3
+            args.nv = 0.01
+
+        if y is not None:
+            if y.ndim == 1:
+                y = y.reshape(-1, 1)
+            self.args = args
+            self.encoder = Encoder(X, y, args)
+            self.decoder = Decoder(X, y, args)
+            self.model = NPR(self.encoder, self.decoder, args)
+
+    @property
+    def n_params(self):
+        return 1
+
+    @property
+    def neg_log_lik(self):
+        return -1
+
+    def estimate(self, X, y):
+        """
+        Estimate the parameters of the Neural Process Regression model.
+
+        This function estimates the parameters of the Neural Process Regression (NPR) model given the data matrix 'X' and target 'y'. 
+        It uses mini-batch gradient descent for optimization and updates the model parameters in place.
+
+        :param X: Data matrix.
+        :param y: Target values. If y is one-dimensional, it is reshaped to (-1, 1).
+        :return: The instance of the norm_np object with updated parameters.
+        """
+        if y.ndim == 1:
+            y = y.reshape(-1, 1)
+        sample_num = X.shape[0]
+        batch_size = self.args.batch_size
+        factor_num = self.args.m
+        mini_batch_num = int(np.floor(sample_num/batch_size))
+        device = self.args.device
+
+        self.scaler = MinMaxScaler()
+        y = self.scaler.fit_transform(y)
+
+        self.reg = []
+        for i in range(factor_num):
+            self.reg.append(LinearRegression())
+            # int(sample_num/10))
+            idx = np.random.randint(0, sample_num, sample_num)
+            self.reg[i].fit(X[idx, :], y[idx, :])
+
+        x_context = np.zeros([sample_num, factor_num, X.shape[1]])
+        y_context = np.zeros([sample_num, factor_num, 1])
+
+        s = X.std(axis=0)
+        for j in range(factor_num):
+            x_context[:, j, :] = X + \
+                np.sqrt(self.args.nv) * s * \
+                np.random.randn(X.shape[0], X.shape[1])
+            y_context[:, j, :] = self.reg[j].predict(x_context[:, j, :])
+
+        x_context = torch.tensor(x_context, device=device, dtype=torch.float)
+        y_context = torch.tensor(y_context, device=device, dtype=torch.float)
+
+        x_all = torch.tensor(np.expand_dims(X, axis=1),
+                             device=device, dtype=torch.float)
+        y_all = torch.tensor(
+            y.reshape(-1, 1, y.shape[1]), device=device, dtype=torch.float)
+
+        self.model.train()
+        epochs = [int(self.args.epochs/4), int(self.args.epochs/2), int(self.args.epochs/5),
+                  int(self.args.epochs-self.args.epochs/4-self.args.epochs/2-self.args.epochs/5)]
+        k = 1
+        for e in range(len(epochs)):
+            optimizer = optim.Adam(self.model.parameters(), lr=10**(-e-2))
+            for j in range(epochs[e]):
+                train_loss = 0
+                for i in range(mini_batch_num):
+                    optimizer.zero_grad()
+                    idx = np.arange(i*batch_size, (i+1)*batch_size)
+                    y_hat, y_hat_84, z_all, z_context, dummy, dummy = self.model(
+                        x_context[idx, :, :], y_context[idx, :, :], x_all[idx, :, :], y_all[idx, :, :])
+                    loss = np_loss(y_hat, y_hat_84,
+                                   y_all[idx, 0, :], z_all, z_context)
+                    loss.backward()
+                    train_loss += loss.item()
+                    optimizer.step()
+                print('Epoch: %d, Loss:%f' % (k, train_loss))
+                k += 1
+        return self
+
+    def predict(self, Xs, X=None, Y=None, theta=None):
+        """
+        Predict the target values for the given test data.
+
+        This function predicts the target values for the given test data 'Xs' using the Neural Process Regression (NPR) model. 
+
+        :param Xs: Test data matrix.
+        :param X: Not used in this function.
+        :param Y: Not used in this function.
+        :param theta: Not used in this function.
+        :return: A tuple containing the predicted target values and the marginal variances for the test data.
+        """
+        sample_num = Xs.shape[0]
+        factor_num = self.args.m
+        x_context_test = np.zeros([sample_num, factor_num, Xs.shape[1]])
+        y_context_test = np.zeros([sample_num, factor_num, 1])
+        for j in range(factor_num):
+            x_context_test[:, j, :] = Xs
+            y_context_test[:, j, :] = self.reg[j].predict(
+                x_context_test[:, j, :])
+        x_context_test = torch.tensor(
+            x_context_test, device=self.args.device, dtype=torch.float)
+        y_context_test = torch.tensor(
+            y_context_test, device=self.args.device, dtype=torch.float)
+        self.model.eval()
+        with torch.no_grad():
+            y_hat, y_hat_84, z_all, z_context, y_sigma, y_sigma_84 = self.model(
+                x_context_test, y_context_test, n=100)
+
+        y_hat = self.scaler.inverse_transform(y_hat.cpu().numpy())
+        y_hat_84 = self.scaler.inverse_transform(y_hat_84.cpu().numpy())
+        y_sigma = y_sigma.cpu().numpy() * (self.scaler.data_max_ - self.scaler.data_min_)
+        y_sigma_84 = y_sigma_84.cpu().numpy() * (self.scaler.data_max_ - self.scaler.data_min_)
+        sigma_al = y_hat - y_hat_84
+        # , z_context[0].cpu().numpy(), z_context[1].cpu().numpy()
+        return y_hat.squeeze(), (y_sigma**2 + sigma_al**2).squeeze()

pcntoolkit/normative_model/norm_rfa.py

@@ -0,0 +1,109 @@
+from __future__ import print_function
+from __future__ import division
+
+import os
+import sys
+import numpy as np
+
+try:  # run as a package if installed
+    from pcntoolkit.normative_model.norm_base import NormBase
+    from pcntoolkit.model.rfa import GPRRFA
+except ImportError:
+    pass
+
+    path = os.path.abspath(os.path.dirname(__file__))
+    if path not in sys.path:
+        sys.path.append(path)
+    del path
+
+    from model.rfa import GPRRFA
+    from norm_base import NormBase
+
+
+class NormRFA(NormBase):
+    """ Classical GPR-based normative modelling approach
+    """
+
+    def __init__(self, X, y=None, theta=None, n_feat=None):
+        """
+        Initialize the NormRFA object.
+
+        This function initializes the NormRFA object with the given arguments. It requires a data matrix 'X' and optionally takes a target 'y', parameters 'theta', and the number of random features 'n_feat'.
+        It initializes the Gaussian Process Regression with Random Feature Approximation (GPRRFA) model and sets the initial parameters.
+
+        :param X: Data matrix. Must be specified.
+        :param y: Not used.
+        :param theta: Parameters for the model. Optional.
+        :param n_feat: Number of random features for the GPRRFA model. Optional.
+        :raises ValueError: If 'X' is not specified.
+        """
+        if (X is not None):
+            if n_feat is None:
+                print("initialising RFA")
+            else:
+                print("initialising RFA with", n_feat, "random features")
+            self.gprrfa = GPRRFA(theta, X, n_feat=n_feat)
+            self._n_params = self.gprrfa.get_n_params(X)
+        else:
+            raise ValueError('Covariates not specified')
+            return
+
+        if theta is None:
+            self.theta0 = np.zeros(self._n_params)
+        else:
+            if len(theta) == self._n_params:
+                self.theta0 = theta
+            else:
+                raise ValueError('hyperparameter vector has incorrect size')
+
+        self.theta = self.theta0
+
+    @property
+    def n_params(self):
+
+        return self._n_params
+
+    @property
+    def neg_log_lik(self):
+        return self.gprrfa.nlZ
+
+    def estimate(self, X, y, theta=None):
+        """
+        Estimate the parameters of the Random Feature Approximation model.
+
+        This function estimates the parameters of the Random Feature Approximation (RFA) model given the data matrix 'X' and target 'y'. 
+        If 'theta' is provided, it is used as the initial parameters for estimation. 
+        Otherwise, the current value of 'self.theta0' is used.
+
+        :param X: Data matrix.
+        :param y: Target values.
+        :param theta: Initial parameters for estimation. Optional.
+        :return: The instance of the NormRFA object with updated parameters.
+        """
+        if theta is None:
+            theta = self.theta0
+        self.gprrfa = GPRRFA(theta, X, y)
+        self.theta = self.gprrfa.estimate(theta, X, y)
+
+        return self
+
+    def predict(self, Xs, X, y, theta=None):
+        """
+        Predict the target values for the given test data.
+
+        This function predicts the target values for the given test data 'Xs' using the Random Feature Approximation (RFA) model. 
+        If 'X' and 'y' are provided, they are used to update the model before prediction. 
+        If 'theta' is provided, it is used as the parameters for prediction. 
+        Otherwise, the current value of 'self.theta' is used.
+
+        :param Xs: Test data matrix.
+        :param X: Training data matrix.
+        :param y: Training target values.
+        :param theta: Parameters for prediction. Optional.
+        :return: A tuple containing the predicted target values and the marginal variances for the test data.
+        """
+        if theta is None:
+            theta = self.theta
+        yhat, s2 = self.gprrfa.predict(theta, X, y, Xs)
+
+        return yhat, s2

pcntoolkit/normative_model/norm_utils.py

@@ -0,0 +1,29 @@
+try:  # run as a package if installed
+    from pcntoolkit.normative_model.norm_blr import NormBLR
+    from pcntoolkit.normative_model.norm_gpr import NormGPR
+    from pcntoolkit.normative_model.norm_rfa import NormRFA
+    from pcntoolkit.normative_model.norm_hbr import NormHBR
+    from pcntoolkit.normative_model.norm_np import NormNP
+except:
+    from norm_blr import NormBLR
+    from norm_gpr import NormGPR
+    from norm_rfa import NormRFA
+    from norm_hbr import NormHBR
+    from norm_np import NormNP
+
+
+def norm_init(X, y=None, theta=None, alg='gpr', **kwargs):
+    if alg == 'gpr':
+        nm = NormGPR(X=X, y=y, theta=theta, **kwargs)
+    elif alg == 'blr':
+        nm = NormBLR(X=X, y=y, theta=theta, **kwargs)
+    elif alg == 'rfa':
+        nm = NormRFA(X=X, y=y, theta=theta, **kwargs)
+    elif alg == 'hbr':
+        nm = NormHBR(**kwargs)
+    elif alg == 'np':
+        nm = NormNP(X=X, y=y, **kwargs)
+    else:
+        raise ValueError("Algorithm " + alg + " not known.")
+
+    return nm