Question

以下是评估用于训练高斯过程（GP）并用于对来自MNIST数据集的图像进行分类的代码。

import numpy as np


from sklearn.metrics.classification import accuracy_score, log_loss
from sklearn.gaussian_process import GaussianProcessClassifier
from sklearn.gaussian_process.kernels import RBF
from sklearn import datasets
from sklearn.datasets import fetch_mldata

import random

SAMPLE_SIZE = 2000

def build_and_optimize(hp_space):
    build_train()
    return

def build_train(hp_space):
    l_scale = hp_space['l_scale']
    bias = hp_space['bias']
    gp_fix = GaussianProcessClassifier(kernel=bias * RBF(length_scale=l_scale), optimizer=None, multi_class='one_vs_rest')

    X_train, X_test, y_train, y_test = prepare_data()


    gp_fix.fit(X_train, y_train)

    print("Log Marginal Likelihood (initial): %.3f"
        % gp_fix.log_marginal_likelihood(gp_fix.kernel_.theta))


    y_ = gp_fix.predict(X_test[0:500])
    print(y_)
    print(y_test[0:500])
    print("Accuracy: %.3f (initial)"
        % (accuracy_score(y_test[0:500], y_)))

    return


def prepare_data():
    mnist = fetch_mldata('MNIST original', data_home='./')
    mnist.keys()

    images = mnist.data
    targets = mnist.target

    X_data = images/255.0
    Y = targets
   shuf = random.sample(range(len(X_data)), SAMPLE_SIZE)

    X_train = []
    for x in shuf: X_train.append(X_data[x])

    y_train = []
    for x in shuf: y_train.append(Y[x])

    c_shuf = set(range(len(X_data))) - set(shuf)

    X_test = []
    for x in c_shuf: X_test.append(X_data[x])

    y_test = []
    for x in c_shuf: y_test.append(Y[x])

    return X_train, X_test, y_train, y_test

if __name__ == "__main__":
    hp_space = {}
    hp_space['l_scale'] = 1.0
    hp_space['bias'] = 1.0

    build_train(hp_space)

似乎模型的训练花费了相当多的时间。但是，预测需要很长时间。任何指针都可能是什么原因？

Answer 1

你可以想到高斯过程和SVM有些相似的模型，都使用内核技巧来构建模型。 Lik SVM，GP需要O（n ^ 3）时间进行训练，其中n是训练集中的数据点数。因此，您应该自然地期望它需要一段时间来训练，并且随着您增加数据集大小，它会快速增长。

类似地，GP预测每预测花费O（n）个时间，类似于最近邻搜索和SVMS。然而，GP解决方案是密集的，这意味着它使用所有训练点进行预测 - 其中SVM是稀疏的，因此它可以抛弃一些。

Answer 2

你可以通过addind n_jobs = -1 加快这个过程，如下所示：

gp_fix = GaussianProcessClassifier(kernel=bias * RBF(length_scale=l_scale), optimizer=None, multi_class='one_vs_rest', n_jobs = -1)

这种方式来自文档：

用于计算的作业数。 如果-1使用所有CPU 。如果给出1，则根本不使用并行计算代码，这对于调试很有用。对于低于-1的n_jobs，使用（n_cpus + 1 + n_jobs）。因此，对于n_jobs = -2，将使用除一个之外的所有CPU。

来源：here

慢预测：Scikit高斯过程分类

2 个答案: