Beispiel #1
0
    def test_gp(plot=False, method='full'):
        """
        Compares model prediction with an exact GP (without optimisation)
        """
        # note that this test fails without latent noise in the case of full Gaussian
        np.random.seed(111)
        num_input_samples = 10
        num_samples = 10000
        gaussian_sigma = .2
        X, Y, kernel = DataSource.normal_generate_samples(num_input_samples, gaussian_sigma, 1)
        kernel = [GPy.kern.RBF(1, variance=1., lengthscale=np.array((1.,)))]

        if method == 'full':
            m = SAVIGP_SingleComponent(X, Y, num_input_samples, UnivariateGaussian(np.array(gaussian_sigma)),
                                          kernel, num_samples, None, 0.001, True, True)

        if method == 'diag':
            m = SAVIGP_Diag(X, Y, num_input_samples, 1, UnivariateGaussian(np.array(gaussian_sigma)),
                                          kernel, num_samples, None, 0.001, True, True)

        # update model using optimal parameters
        # gp = SAVIGP_Test.gpy_prediction(X, Y, gaussian_sigma, kernel[0])
        # gp_mean, gp_var = gp.predict(X, full_cov=True)
        # m.MoG.m[0,0] = gp_mean[:,0]
        # m.MoG.update_covariance(0, gp_var - gaussian_sigma * np.eye(10))

        try:
            folder_name = 'test' + '_' + ModelLearn.get_ID()
            logger = ModelLearn.get_logger(folder_name, logging.DEBUG)

            Optimizer.optimize_model(m, 10000, logger, ['mog'])
        except KeyboardInterrupt:
            pass
        sa_mean, sa_var = m.predict(X)
        gp = SAVIGP_Test.gpy_prediction(X, Y, gaussian_sigma, deepcopy(kernel[0]))
        gp_mean, gp_var = gp.predict(X)
        mean_error = (np.abs(sa_mean - gp_mean)).sum() / sa_mean.shape[0]
        var_error = (np.abs(sa_var - gp_var)).sum() / gp_var.T.shape[0]
        if mean_error < 0.1:
            print bcolors.OKBLUE, "passed: mean gp prediction ", mean_error
        else:
            print bcolors.WARNING, "failed: mean gp prediction ", mean_error
        print bcolors.ENDC
        if var_error < 0.1:
            print bcolors.OKBLUE, "passed: var gp prediction ", var_error
        else:
            print bcolors.WARNING, "failed: var gp prediction ", var_error
        print bcolors.ENDC
        if plot:
            plot_fit(m)
            gp.plot()
            show(block=True)
Beispiel #2
0
    def creep_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.creep_data()

        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'creep'
        scaler = preprocessing.StandardScaler().fit(Xtrain)
        Xtrain = scaler.transform(Xtrain)
        Xtest = scaler.transform(Xtest)
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, True)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000

        cond_ll = WarpLL(np.array([3.8715, 3.8898, 2.8759]),
                         np.array([1.5925, -1.3360, -2.0289]),
                         np.array([0.7940, -4.1855, -3.0289]),
                         np.log(0.01))

        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['mog', 'hyp', 'll'], MinTransformation, True,
                                 config['log_level'], False, latent_noise=0.001,
                                 opt_per_iter={'mog': 25, 'hyp': 25, 'll': 25},
                                 max_iter=200))
Beispiel #3
0
    def boston_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.boston_data()
        d = data[config['run_id'] - 1]
        names = []
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'boston'
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, True)
        # gaussian_sigma = np.var(Ytrain)/4 + 1e-4
        gaussian_sigma = 1.0
        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        cond_ll = UnivariateGaussian(np.array(gaussian_sigma))
        num_samples = 2000

        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['hyp', 'mog', 'll'], MeanTransformation, True,
                                 config['log_level'], False, latent_noise=0.001,
                                 opt_per_iter={'mog': 25, 'hyp': 25, 'll': 25},
                                 max_iter=200))
        return names
Beispiel #4
0
    def wisconsin_breast_cancer_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.wisconsin_breast_cancer_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'breast_cancer'

        # uncomment these lines to use softmax
        # kernel = Experiments.get_kernels(Xtrain.shape[1], 2, False)
        # Ytrain = np.array([(Ytrain[:,0] + 1) / 2, (-Ytrain[:,0] + 1) / 2]).T
        # Ytest = np.array([(Ytest[:,0] + 1) / 2, (-Ytest[:,0] + 1) / 2]).T
        # cond_ll = SoftmaxLL(2)

        # uncomment these lines to use logistic
        cond_ll = LogisticLL()
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, False)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['mog', 'hyp'], IdentityTransformation, True,
                                 config['log_level'], False, latent_noise=0.001,
                                 opt_per_iter={'mog': 25, 'hyp': 25, 'll': 25},
                                 max_iter=200))
        return names
Beispiel #5
0
    def mining_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.mining_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'mining'
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, False)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        cond_ll = LogGaussianCox(math.log(191. / 811))
        kernel[0].variance = 1.0
        kernel[0].lengthscale = 13516.

        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['mog'], IdentityTransformation, True,
                                 config['log_level'], True, latent_noise=0.001,
                                 opt_per_iter={'mog': 15000},
                                 max_iter=1))
        return names
Beispiel #6
0
    def abalone_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.abalone_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'abalone'
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, False)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000

        cond_ll = WarpLL(np.array([-2.0485, 1.7991, 1.5814]),
                         np.array([2.7421, 0.9426, 1.7804]),
                         np.array([0.1856, 0.7024, -0.7421]),
                         np.log(0.1))

        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['mog', 'hyp', 'll'], MinTransformation, True,
                                 config['log_level'], False, latent_noise=0.001,
                                 opt_per_iter={'mog': 25, 'hyp': 25, 'll': 25},
                                 max_iter=200))
Beispiel #7
0
    def wisconsin_breast_cancer_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.wisconsin_breast_cancer_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'breast_cancer'

        # uncomment these lines to use softmax
        # kernel = Experiments.get_kernels(Xtrain.shape[1], 2, False)
        # Ytrain = np.array([(Ytrain[:,0] + 1) / 2, (-Ytrain[:,0] + 1) / 2]).T
        # Ytest = np.array([(Ytest[:,0] + 1) / 2, (-Ytest[:,0] + 1) / 2]).T
        # cond_ll = SoftmaxLL(2)

        # uncomment these lines to use logistic
        cond_ll = LogisticLL()
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, False)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['mog', 'hyp'],
                                 IdentityTransformation,
                                 True,
                                 config['log_level'],
                                 False,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 25,
                                     'hyp': 25,
                                     'll': 25
                                 },
                                 max_iter=200))
        return names
Beispiel #8
0
    def sarcos_all_joints_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.sarcos_all_joints_data()

        names = []
        d = data[0]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'sarcos_all_joints'

        scaler = preprocessing.StandardScaler().fit(Xtrain)
        Xtrain = scaler.transform(Xtrain)
        Xtest = scaler.transform(Xtest)

        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 8, False)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000

        cond_ll = CogLL(0.1, 7, 1)

        if 'n_thread' in config.keys():
            n_threads = config['n_thread']
        else:
            n_threads = 1

        if 'partition_size' in config.keys():
            partition_size = config['partition_size']
        else:
            partition_size = 3000

        image = None
        if 'image' in config.keys():
            image = config['image']

        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['mog', 'll', 'hyp'], MeanStdYTransformation, True,
                                 config['log_level'], False, latent_noise=0.001,
                                 opt_per_iter={'mog': 50, 'hyp': 10, 'll': 10},
                                 max_iter=200,
                                 partition_size=partition_size,
                                 ftol=10,
                                 n_threads=n_threads,
                                 model_image_file=image))
Beispiel #9
0
    def creep_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.creep_data()

        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'creep'
        scaler = preprocessing.StandardScaler().fit(Xtrain)
        Xtrain = scaler.transform(Xtrain)
        Xtest = scaler.transform(Xtest)
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, True)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000

        cond_ll = WarpLL(np.array([3.8715, 3.8898, 2.8759]),
                         np.array([1.5925, -1.3360, -2.0289]),
                         np.array([0.7940, -4.1855, -3.0289]), np.log(0.01))

        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['mog', 'hyp', 'll'],
                                 MinTransformation,
                                 True,
                                 config['log_level'],
                                 False,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 25,
                                     'hyp': 25,
                                     'll': 25
                                 },
                                 max_iter=200))
Beispiel #10
0
    def USPS_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.USPS_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'USPS'
        kernel = [
            ExtRBF(Xtrain.shape[1],
                   variance=2,
                   lengthscale=np.array((4., )),
                   ARD=False) for j in range(3)
        ]
        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        cond_ll = SoftmaxLL(3)

        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['mog', 'hyp'],
                                 IdentityTransformation,
                                 True,
                                 config['log_level'],
                                 False,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 25,
                                     'hyp': 25,
                                     'll': 25
                                 },
                                 max_iter=300))
Beispiel #11
0
    def abalone_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.abalone_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'abalone'
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, False)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000

        cond_ll = WarpLL(np.array([-2.0485, 1.7991, 1.5814]),
                         np.array([2.7421, 0.9426, 1.7804]),
                         np.array([0.1856, 0.7024, -0.7421]), np.log(0.1))

        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['mog', 'hyp', 'll'],
                                 MinTransformation,
                                 True,
                                 config['log_level'],
                                 False,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 25,
                                     'hyp': 25,
                                     'll': 25
                                 },
                                 max_iter=200))
    def mining_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.mining_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'mining'
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, False)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        cond_ll = LogGaussianCox(math.log(191. / 811))
        kernel[0].variance = 1.0
        kernel[0].lengthscale = 13516.

        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['mog'],
                                 IdentityTransformation,
                                 True,
                                 config['log_level'],
                                 True,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 15000,
                                     'hyp': 25,
                                     'll': 25
                                 },
                                 max_iter=1))
        return names
Beispiel #13
0
    def boston_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.boston_data()
        d = data[config['run_id'] - 1]
        names = []
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'boston'
        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 1, True)
        # gaussian_sigma = np.var(Ytrain)/4 + 1e-4
        gaussian_sigma = 1.0
        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        cond_ll = UnivariateGaussian(np.array(gaussian_sigma))
        num_samples = 2000

        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['hyp', 'mog', 'll'],
                                 MeanTransformation,
                                 True,
                                 config['log_level'],
                                 False,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 25,
                                     'hyp': 25,
                                     'll': 25
                                 },
                                 max_iter=200))
        return names
Beispiel #14
0
    def USPS_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.USPS_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'USPS'
        kernel = [ExtRBF(Xtrain.shape[1], variance=2, lengthscale=np.array((4.,)), ARD=False) for j in range(3)]
        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        cond_ll = SoftmaxLL(3)

        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['mog', 'hyp'], IdentityTransformation, True,
                                 config['log_level'], False, latent_noise=0.001,
                                 opt_per_iter={'mog': 25, 'hyp': 25, 'll': 25},
                                 max_iter=300))
Beispiel #15
0
    def test_model_learn(config):
        """
        Compares the model output with exact GP
        """
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        names = []
        num_input_samples = 20
        gaussian_sigma = .2

        X, Y, kernel = DataSource.normal_generate_samples(num_input_samples, gaussian_sigma)
        train_n = int(0.5 * num_input_samples)

        Xtrain = X[:train_n, :]
        Ytrain = Y[:train_n, :]
        Xtest = X[train_n:, :]
        Ytest = Y[train_n:, :]
        kernel1 = ModelLearn.get_kernels(Xtrain.shape[1], 1, True)
        kernel2 = ModelLearn.get_kernels(Xtrain.shape[1], 1, True)
        gaussian_sigma = 1.0

        #number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 10000
        cond_ll = UnivariateGaussian(np.array(gaussian_sigma))

        n1, _ = ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel1, method,
                                           'test_' + ModelLearn.get_ID(), 'test', num_inducing,
                                     num_samples, sparsify_factor, ['mog', 'll', 'hyp'], IdentityTransformation, True,
                                           logging.DEBUG, True)

        n2, _ =ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel2, 'gp',
                                           'test_' + ModelLearn.get_ID(), 'test', num_inducing,
                                     num_samples, sparsify_factor, ['mog', 'll', 'hyp'], IdentityTransformation)

        PlotOutput.plot_output('test', ModelLearn.get_output_path(), [n1, n2], None, False)
Beispiel #16
0
    def sarcos_all_joints_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.sarcos_all_joints_data()

        names = []
        d = data[0]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'sarcos_all_joints'

        scaler = preprocessing.StandardScaler().fit(Xtrain)
        Xtrain = scaler.transform(Xtrain)
        Xtest = scaler.transform(Xtest)

        kernel = ExperimentSetup.get_kernels(Xtrain.shape[1], 8, False)

        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000

        cond_ll = CogLL(0.1, 7, 1)

        if 'n_thread' in config.keys():
            n_threads = config['n_thread']
        else:
            n_threads = 1

        if 'partition_size' in config.keys():
            partition_size = config['partition_size']
        else:
            partition_size = 3000

        image = None
        if 'image' in config.keys():
            image = config['image']

        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['mog', 'll', 'hyp'],
                                 MeanStdYTransformation,
                                 True,
                                 config['log_level'],
                                 False,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 50,
                                     'hyp': 10,
                                     'll': 10
                                 },
                                 max_iter=200,
                                 partition_size=partition_size,
                                 ftol=10,
                                 n_threads=n_threads,
                                 model_image_file=image))
Beispiel #17
0
    def MNIST_binary_inducing_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.mnist_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain_full = d['train_Y']
        Xtest = d['test_X']
        Ytest_full = d['test_Y']
        name = 'mnist_binary'

        # uncomment these lines to change the resolution
        # res = 13
        # current_res = int(np.sqrt(Xtrain.shape[1]))
        # X_train_resized = np.empty((Xtrain.shape[0], res * res))
        # X_test_resized = np.empty((Xtest.shape[0], res * res))
        # for n in range(Xtrain.shape[0]):
        #     im = Image.fromarray(Xtrain[n, :].reshape((current_res, current_res)))
        #     im = im.resize((res, res))
        #     X_train_resized[n] = np.array(im).flatten()
        #
        # for n in range(Xtest.shape[0]):
        #     im = Image.fromarray(Xtest[n, :].reshape((current_res, current_res)))
        #     im = im.resize((res, res))
        #     X_test_resized[n] = np.array(im).flatten()
        #
        #
        # Xtrain = X_train_resized
        # Xtest = X_test_resized

        Ytrain = np.apply_along_axis(
            lambda x: x[1:10:2].sum() - x[0:10:2].sum(), 1,
            Ytrain_full).astype(int)[:, np.newaxis]
        Ytest = np.apply_along_axis(
            lambda x: x[1:10:2].sum() - x[0:10:2].sum(), 1,
            Ytest_full).astype(int)[:, np.newaxis]

        kernel = [
            ExtRBF(Xtrain.shape[1],
                   variance=11,
                   lengthscale=np.array((9., )),
                   ARD=False) for j in range(1)
        ]
        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        cond_ll = LogisticLL()

        if 'n_thread' in config.keys():
            n_threads = config['n_thread']
        else:
            n_threads = 1

        if 'partition_size' in config.keys():
            partition_size = config['partition_size']
        else:
            partition_size = 3000

        image = None
        if 'image' in config.keys():
            image = config['image']

        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['mog', 'hyp', 'inducing'],
                                 IdentityTransformation,
                                 False,
                                 config['log_level'],
                                 False,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 60,
                                     'hyp': 15,
                                     'inducing': 6
                                 },
                                 max_iter=9,
                                 n_threads=n_threads,
                                 ftol=10,
                                 model_image_file=image,
                                 partition_size=partition_size))
Beispiel #18
0
        # plots for an specific experiment
        # PlotOutput.plot_output_all('abalone_graph', Experiments.get_output_path(),
        #                            lambda x: x['experiment'] == 'abalone', False)


def run_config(config):
    try:
        logger.info('started config: ' + str(config))
        getattr(ExperimentSetup, config['method_to_run'])(config)
        logger.info('finished config: ' + str(config))
    except Exception as e:
        logger.exception(config)


if __name__ == '__main__':
    logger = ModelLearn.get_logger(ModelLearn.get_logger_path(), 'general_' + ModelLearn.get_ID(), logging.DEBUG)

    # uncomment to run experiments in parallel
    # ExperimentRunner.run_parallel(3)

    # runs an individual configuration
    # ExperimentRunner.boston_experiment()
    # ExperimentRunner.wisconsin_breast_experiment()
    # ExperimentRunner.USPS_experiment()
    # ExperimentRunner.mining_experiment()
    # ExperimentRunner.abalone_experiment()
    # ExperimentRunner.mnist_binary_inducing_experiment()
    ExperimentRunner.mnist_binary_experiment()
    # ExperimentRunner.sarcos_all_joins_experiment()
    # ExperimentRunner.sarcos_experiment()
Beispiel #19
0
    def MNIST_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.mnist_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'mnist'

        # uncomment these lines to delete unused features
        # features_rm = np.array([])
        # for n in range(Xtrain.shape[1]):
        # if Xtrain[:, n].sum() ==0:
        #         features_rm = np.append(features_rm, n)
        # Xtrain = np.delete(Xtrain, features_rm.astype(int), 1)
        # Xtest = np.delete(Xtest, features_rm.astype(int), 1)


        # uncomment these lines to change the resolution
        # res = 13
        # current_res = int(np.sqrt(Xtrain.shape[1]))
        # X_train_resized = np.empty((Xtrain.shape[0], res * res))
        # X_test_resized = np.empty((Xtest.shape[0], res * res))
        # for n in range(Xtrain.shape[0]):
        #     im = Image.fromarray(Xtrain[n, :].reshape((current_res, current_res)))
        #     im = im.resize((res, res))
        #     X_train_resized[n] = np.array(im).flatten()
        #
        # for n in range(Xtest.shape[0]):
        #     im = Image.fromarray(Xtest[n, :].reshape((current_res, current_res)))
        #     im = im.resize((res, res))
        #     X_test_resized[n] = np.array(im).flatten()
        #
        #
        # Xtrain = X_train_resized
        # Xtest = X_test_resized

        kernel = [ExtRBF(Xtrain.shape[1], variance=11, lengthscale=np.array((9.,)), ARD=False) for j in range(10)]
        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        cond_ll = SoftmaxLL(10)

        if 'n_thread' in config.keys():
            n_threads = config['n_thread']
        else:
            n_threads = 1

        if 'partition_size' in config.keys():
            partition_size = config['partition_size']
        else:
            partition_size = 3000

        image = None
        if 'image' in config.keys():
            image = config['image']

        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['mog', 'hyp'], IdentityTransformation, False,
                                 config['log_level'], False, latent_noise=0.001,
                                 opt_per_iter={'mog': 50, 'hyp': 10},
                                 max_iter=300, n_threads=n_threads, ftol=10,
                                 model_image_file=image, partition_size=partition_size))
Beispiel #20
0
    def MNIST_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.mnist_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain = d['train_Y']
        Xtest = d['test_X']
        Ytest = d['test_Y']
        name = 'mnist'

        # uncomment these lines to delete unused features
        # features_rm = np.array([])
        # for n in range(Xtrain.shape[1]):
        # if Xtrain[:, n].sum() ==0:
        #         features_rm = np.append(features_rm, n)
        # Xtrain = np.delete(Xtrain, features_rm.astype(int), 1)
        # Xtest = np.delete(Xtest, features_rm.astype(int), 1)

        # uncomment these lines to change the resolution
        # res = 13
        # current_res = int(np.sqrt(Xtrain.shape[1]))
        # X_train_resized = np.empty((Xtrain.shape[0], res * res))
        # X_test_resized = np.empty((Xtest.shape[0], res * res))
        # for n in range(Xtrain.shape[0]):
        #     im = Image.fromarray(Xtrain[n, :].reshape((current_res, current_res)))
        #     im = im.resize((res, res))
        #     X_train_resized[n] = np.array(im).flatten()
        #
        # for n in range(Xtest.shape[0]):
        #     im = Image.fromarray(Xtest[n, :].reshape((current_res, current_res)))
        #     im = im.resize((res, res))
        #     X_test_resized[n] = np.array(im).flatten()
        #
        #
        # Xtrain = X_train_resized
        # Xtest = X_test_resized

        kernel = [
            ExtRBF(Xtrain.shape[1],
                   variance=11,
                   lengthscale=np.array((9., )),
                   ARD=False) for j in range(10)
        ]
        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        cond_ll = SoftmaxLL(10)

        if 'n_thread' in config.keys():
            n_threads = config['n_thread']
        else:
            n_threads = 1

        if 'partition_size' in config.keys():
            partition_size = config['partition_size']
        else:
            partition_size = 3000

        image = None
        if 'image' in config.keys():
            image = config['image']

        names.append(
            ModelLearn.run_model(Xtest,
                                 Xtrain,
                                 Ytest,
                                 Ytrain,
                                 cond_ll,
                                 kernel,
                                 method,
                                 name,
                                 d['id'],
                                 num_inducing,
                                 num_samples,
                                 sparsify_factor, ['mog', 'hyp'],
                                 IdentityTransformation,
                                 False,
                                 config['log_level'],
                                 False,
                                 latent_noise=0.001,
                                 opt_per_iter={
                                     'mog': 50,
                                     'hyp': 10
                                 },
                                 max_iter=300,
                                 n_threads=n_threads,
                                 ftol=10,
                                 model_image_file=image,
                                 partition_size=partition_size))
Beispiel #21
0
    def MNIST_binary_inducing_data(config):
        method = config['method']
        sparsify_factor = config['sparse_factor']
        np.random.seed(12000)
        data = DataSource.mnist_data()
        names = []
        d = data[config['run_id'] - 1]
        Xtrain = d['train_X']
        Ytrain_full = d['train_Y']
        Xtest = d['test_X']
        Ytest_full = d['test_Y']
        name = 'mnist_binary'

        # uncomment these lines to change the resolution
        # res = 13
        # current_res = int(np.sqrt(Xtrain.shape[1]))
        # X_train_resized = np.empty((Xtrain.shape[0], res * res))
        # X_test_resized = np.empty((Xtest.shape[0], res * res))
        # for n in range(Xtrain.shape[0]):
        #     im = Image.fromarray(Xtrain[n, :].reshape((current_res, current_res)))
        #     im = im.resize((res, res))
        #     X_train_resized[n] = np.array(im).flatten()
        #
        # for n in range(Xtest.shape[0]):
        #     im = Image.fromarray(Xtest[n, :].reshape((current_res, current_res)))
        #     im = im.resize((res, res))
        #     X_test_resized[n] = np.array(im).flatten()
        #
        #
        # Xtrain = X_train_resized
        # Xtest = X_test_resized

        Ytrain = np.apply_along_axis(lambda x: x[1:10:2].sum() - x[0:10:2].sum(), 1, Ytrain_full).astype(int)[:, np.newaxis]
        Ytest = np.apply_along_axis(lambda x: x[1:10:2].sum() - x[0:10:2].sum(), 1, Ytest_full).astype(int)[:, np.newaxis]

        kernel = [ExtRBF(Xtrain.shape[1], variance=11, lengthscale=np.array((9.,)), ARD=False) for j in range(1)]
        # number of inducing points
        num_inducing = int(Xtrain.shape[0] * sparsify_factor)
        num_samples = 2000
        cond_ll = LogisticLL()

        if 'n_thread' in config.keys():
            n_threads = config['n_thread']
        else:
            n_threads = 1

        if 'partition_size' in config.keys():
            partition_size = config['partition_size']
        else:
            partition_size = 3000

        image = None
        if 'image' in config.keys():
            image = config['image']

        names.append(
            ModelLearn.run_model(Xtest, Xtrain, Ytest, Ytrain, cond_ll, kernel, method, name, d['id'], num_inducing,
                                 num_samples, sparsify_factor, ['mog', 'hyp', 'inducing'], IdentityTransformation, False,
                                 config['log_level'], False, latent_noise=0.001,
                                 opt_per_iter={'mog': 60, 'hyp': 15, 'inducing': 6},
                                 max_iter=9, n_threads=n_threads, ftol=10,
                                 model_image_file=image, partition_size=partition_size))
Beispiel #22
0
 def plot():
     PlotOutput.plot_output_all('boston', ModelLearn.get_output_path(),
                                lambda x: x['method'] == 'full', False)
Beispiel #23
0
ModelLearn.run_model(Xtest,
                     Xtrain,
                     Ytest,
                     Ytrain,
                     cond_ll,
                     kernels,
                     method,
                     name,
                     d['id'],
                     num_inducing,
                     num_samples,
                     num_inducing / Xtrain.shape[0],

                     # optimise hyper-parameters (hyp), posterior parameters (mog), and likelihood parameters (ll)
                     ['hyp', 'mog', 'll'],

                     # Transform data before training
                     MeanTransformation,

                     # place inducting points on training data. If False, they will be places using clustering
                     True,

                     # level of logging
                     logging.DEBUG,

                     # do not export training data into csv files
                     False,

                     # add a small latent noise to the kernel for stability of numerical computations
                     latent_noise=0.001,

                     # for how many iterations each set of parameters will be optimised
                     opt_per_iter={'mog': 25, 'hyp': 25, 'll': 25},

                     # total number of global optimisations
                     max_iter=200,

                     # number of threads
                     n_threads=1,

                     # size of each partition of data
                     partition_size=3000)
Beispiel #24
0
 def plot():
     PlotOutput.plot_output_all('boston', ModelLearn.get_output_path(),
                                lambda x: x['method'] == 'full', False)
Beispiel #25
0
        # PlotOutput.plot_output_all('abalone_graph', Experiments.get_output_path(),
        #                            lambda x: x['experiment'] == 'abalone', False)


def run_config(config):
    try:
        logger.info('started config: ' + str(config))
        getattr(ExperimentSetup, config['method_to_run'])(config)
        logger.info('finished config: ' + str(config))
    except Exception as e:
        logger.exception(config)


if __name__ == '__main__':
    logger = ModelLearn.get_logger(ModelLearn.get_logger_path(),
                                   'general_' + ModelLearn.get_ID(),
                                   logging.DEBUG)

    # uncomment to run experiments in parallel
    # ExperimentRunner.run_parallel(3)

    # runs an individual configuration
    ExperimentRunner.boston_experiment()
    # ExperimentRunner.wisconsin_breast_experiment()
    # ExperimentRunner.USPS_experiment()
    # ExperimentRunner.mining_experiment()
    # ExperimentRunner.abalone_experiment()
    # ExperimentRunner.mnist_binary_inducing_experiment()
#    ExperimentRunner.mnist_binary_experiment()
# ExperimentRunner.sarcos_all_joins_experiment()
# ExperimentRunner.sarcos_experiment()