python、theano、GPU、PicklingError:Can'；泡菜

我不熟悉python和theano。我想带一个演示来工作，它声称在GPU上并行化目标函数的优化，在theano中编译

演示可以在这里找到

为了在windows上运行它，我不得不修改一些代码。对于文件

vssgp_example.py

我将其更改为：

from vssgp_opt import VSSGP_opt
from scipy.optimize import minimize
import numpy as np
from numpy.random import randn, rand
np.set_printoptions(precision=2, suppress=True)
import pylab; pylab.ion() # turn interactive mode on

def STARTME(N = 1000, Q=1, D=1, K=50, components=2, init_period=1e32, init_lengthscales=1, sf2s=np.array([1, 5]), tau=1):
    # Some synthetic data to play with
    X = rand(N,Q) * 5*np.pi 
    X = np.sort(X, axis=0)
    Z = rand(Q,K,components) * 5*np.pi 
    #a, b, c, d, e, f = randn(), randn(), randn(), randn(), randn(), randn()
    #a, b, c, d, e, f = 0.6, 0.7, -0.6, 0.5, -0.1, -0.8
    #a, b, c, d, e, f = -0.6, -0.3, -0.6, 0.6, 0.7, 0.6
    #a, b, c, d, e, f = -0.5, -0.3, -0.6, 0.1, 1.1, 0.1
    a, b, c, d, e, f = 0.6, -1.8, -0.5, -0.5, 1.7, 0
    Y = a*np.sin(b*X+c) + d*np.sin(e*X+f)

    # Initialise near the posterior:
    mu = randn(Q,K,components)
    # TODO: Currently tuned by hand to smallest value that doesn't diverge; we break symmetry to allow for some to get very small while others very large
    feature_lengthscale = 5 # features are non-diminishing up to feature_lengthscale / lengthscale from z / lengthscale
    lSigma = np.log(randn(Q,K,components)**2 / feature_lengthscale**2) # feature weights are np.exp(-0.5 * (x-z)**2 * Sigma / lengthscale**2)
    lalpha = np.log(rand(K,components)*2*np.pi)
    lalpha_delta = np.log(rand(K,components) * (2*np.pi - lalpha))
    m = randn(components*K,D)
    ls = np.zeros((components*K,D)) - 4
    lhyp = np.log(1 + 1e-2*randn(2*Q+1, components)) # break symmetry
    lhyp[0,:] += np.log(sf2s) # sf2
    lhyp[1:Q+1,:] += np.log(init_lengthscales) # length-scales
    lhyp[Q+1:,:] += np.log(init_period) # period
    ltau = np.log(tau) # precision
    lstsq = np.linalg.lstsq(np.hstack([X, np.ones((N,1))]), Y)[0]
    a = 0*np.atleast_2d(lstsq[0]) # mean function slope
    b = 0*lstsq[1] # mean function intercept

    opt_params = {'Z': Z, 'm': m, 'ls': ls, 'mu': mu, 'lSigma': lSigma, 'lhyp': lhyp, 'ltau': ltau}
    fixed_params = {'lalpha': lalpha, 'lalpha_delta': lalpha_delta, 'a': a, 'b': b}
    inputs = {'X': X, 'Y': Y}
    vssgp_opt = VSSGP_opt(N, Q, D, K, inputs, opt_params, fixed_params, use_exact_A=True, parallel = True, batch_size = 25, print_interval=1)

    # LBFGS
    x0 = np.concatenate([np.atleast_2d(opt_params[n]).flatten() for n in vssgp_opt.opt_param_names])
    pylab.figure(num=None, figsize=(12, 9), dpi=80, facecolor='w', edgecolor='w')
    vssgp_opt.callback(x0)
    res = minimize(vssgp_opt.func, x0, method='L-BFGS-B', jac=vssgp_opt.fprime,
        options={'ftol': 0, 'disp': False, 'maxiter': 500}, tol=0, callback=vssgp_opt.callback)

    raw_input("PRESS ENTER TO CONTINUE.")

    return (res)

因此，我将大部分代码放在一个新函数STARTME（）中，这样它就不在modul stage上了

我还将

vssgp_opt.py

更改为：

import numpy as np
from vssgp_model import VSSGP
import multiprocessing

class VSSGP_opt():
    def __init__(self, N, Q, D, K, inputs, opt_params, fixed_params, use_exact_A = False, test_set = {},
                 parallel = False, batch_size = None, components = None, print_interval = None):
        self.vssgp, self.N, self.Q, self.K, self.fixed_params = VSSGP(use_exact_A), N, Q, K, fixed_params
        self.use_exact_A, self.parallel, self.batch_size = use_exact_A, parallel, batch_size
        self.inputs, self.test_set = inputs, test_set
        self.print_interval = 10 if print_interval is None else print_interval
        self.opt_param_names = [n for n,_ in opt_params.iteritems()]
        opt_param_values = [np.atleast_2d(opt_params[n]) for n in self.opt_param_names]
        self.shapes = [v.shape for v in opt_param_values]
        self.sizes = [sum([np.prod(x) for x in self.shapes[:i]]) for i in xrange(len(self.shapes)+1)]
        self.components = opt_params['lSigma'].shape[2] if components is None else components
        self.colours = [np.random.rand(3,1) for c in xrange(self.components)]
        self.callback_counter = [0]
        if batch_size is not None:
            if parallel:
                self.pool = multiprocessing.Pool(int(self.N / self.batch_size))
            else:
                self.params = np.concatenate([v.flatten() for v in opt_param_values])
                self.param_updates = np.zeros_like(self.params)
                self.moving_mean_squared = np.zeros_like(self.params)
                self.learning_rates = 1e-2*np.ones_like(self.params)

    def extend(self, x, y, z = {}):

        return dict(x.items() + y.items() + z.items())

    def eval_f_LL(self, arguments):
        out_f = self.vssgp.f['LL'](**arguments)
        return (out_f)

    def eval_g_LL(self, arguments):
        out_g = self.vssgp.g['LL'](**arguments)
        return (out_g)

    def unpack(self, x):
        x_param_values = [x[self.sizes[i-1]:self.sizes[i]].reshape(self.shapes[i-1]) for i in xrange(1,len(self.shapes)+1)]
        params = {n:v for (n,v) in zip(self.opt_param_names, x_param_values)}
        if 'ltau' in params:
            params['ltau'] = params['ltau'].squeeze()
        return params

    def func(self, x):
        params = self.extend(self.fixed_params, self.unpack(x))
        if self.batch_size is not None:
            X, Y, splits = self.inputs['X'], self.inputs['Y'], int(self.N / self.batch_size)
            if self.parallel:
                arguments = [(X[i::splits], Y[i::splits], params) for i in xrange(splits)]
                LL = sum(self.pool.map_async(self.eval_f_LL, arguments).get(9999999))
                KL = self.vssgp.f['KL'](**self.extend({'X': [[0]], 'Y': [[0]]}, params))
            else:
                split = np.random.randint(splits)
                LL = self.N / self.batch_size * self.vssgp.f['LL'](**self.extend({'X': X[split::splits], 'Y': Y[split::splits]}, params))
                print LL
                KL = self.vssgp.f['KL'](**self.extend({'X': [[0]], 'Y': [[0]]}, params))
        else:
            params = self.extend(self.inputs, params)
            LL, KL = self.vssgp.f['LL'](**params), self.vssgp.f['KL'](**params)
        return -(LL - KL)

    def fprime(self, x):
        grads, params = [], self.extend(self.fixed_params, self.unpack(x))
        for n in self.opt_param_names:
            if self.batch_size is not None:
                X, Y, splits = self.inputs['X'], self.inputs['Y'], int(self.N / self.batch_size)
                if self.parallel:
                    arguments = [(n, X[i::splits], Y[i::splits], params) for i in xrange(splits)]
                    dLL = sum(self.pool.map_async(self.eval_g_LL, arguments).get(9999999))
                    dKL = self.vssgp.g[n]['KL'](**self.extend({'X': [[0]], 'Y': [[0]]}, params))
                else:
                    split = np.random.randint(splits)
                    dLL = self.N / self.batch_size * self.vssgp.g[n]['LL'](**self.extend({'X': X[split::splits], 'Y': Y[split::splits]}, params))
                    dKL = self.vssgp.g[n]['KL'](**self.extend({'X': [[0]], 'Y': [[0]]}, params))
            else:
                params = self.extend(self.inputs, params)
                dLL, dKL = self.vssgp.g[n]['LL'](**params), self.vssgp.g[n]['KL'](**params)
            grads += [-(dLL - dKL)]
        return np.concatenate([grad.flatten() for grad in grads])

    def callback(self, x):
        if self.callback_counter[0]%self.print_interval == 0:
            opt_params = self.unpack(x)
            params = self.extend(self.inputs, self.fixed_params, opt_params)
            LL = self.vssgp.f['LL'](**params)
            KL = self.vssgp.f['KL'](**params)
            print LL - KL
        self.callback_counter[0] += 1

以除去全局变量。现在，当我执行函数STARTME（）时：

它一直正常运行，直到vssgp_opt.py的第53行出现错误：

Traceback (most recent call last):

  File "<ipython-input-4-f919e99b6eea>", line 1, in <module>
    if __name__== '__main__' : STARTME()

  File "C:/Users/flo9fe/Desktop/vSSGP_LVM/vssgp_example.py", line 48, in STARTME
    options={'ftol': 0, 'disp': False, 'maxiter': 500}, tol=0, callback=vssgp_opt.callback)

  File "C:\Program Files\Anaconda2\lib\site-packages\scipy\optimize\_minimize.py", line 450, in minimize
    callback=callback, **options)

  File "C:\Program Files\Anaconda2\lib\site-packages\scipy\optimize\lbfgsb.py", line 328, in _minimize_lbfgsb
    f, g = func_and_grad(x)

  File "C:\Program Files\Anaconda2\lib\site-packages\scipy\optimize\lbfgsb.py", line 278, in func_and_grad
    f = fun(x, *args)

  File "C:\Program Files\Anaconda2\lib\site-packages\scipy\optimize\optimize.py", line 292, in function_wrapper
    return function(*(wrapper_args + args))

  File "vssgp_opt.py", line 53, in func
    LL = sum(self.pool.map_async(self.eval_f_LL, arguments).get(9999999))

  File "C:\Program Files\Anaconda2\lib\multiprocessing\pool.py", line 567, in get
    raise self._value

PicklingError: Can't pickle <type 'instancemethod'>: attribute lookup __builtin__.instancemethod failed

回溯（最近一次呼叫最后一次）：
文件“”，第1行，在
如果uuuu name uuuuuu=='uuuuuu main uuuuuuuuuuuuu'：STARTME（）
文件“C:/Users/flo9fe/Desktop/vSSGP_LVM/vSSGP_example.py”，第48行，在STARTME中
选项={'ftol'：0，'disp'：False，'maxiter'：500}，tol=0，callback=vssgp_opt.callback）
文件“C:\Program Files\Anaconda2\lib\site packages\scipy\optimize\\u minimize.py”，第450行，最小化
回调=回调，**选项）
文件“C:\Program Files\Anaconda2\lib\site packages\scipy\optimize\lbfgsb.py”，第328行，在_minimize\lbfgsb中
f、 g=函数和梯度（x）
文件“C:\Program Files\Anaconda2\lib\site packages\scipy\optimize\lbfgsb.py”，第278行，在func_和_grad中
f=乐趣（x，*args）
文件“C:\Program Files\Anaconda2\lib\site packages\scipy\optimize\optimize.py”，第292行，在函数包装器中
返回函数（*（包装器参数+参数））
文件“vssgp_opt.py”，第53行，func格式
LL=sum（self.pool.map_async（self.eval_f_LL，参数）.get（999999））
get中第567行的文件“C:\Program Files\Anaconda2\lib\multiprocessing\pool.py”
提升自我价值
PicklingError:无法pickle:属性查找\内置\实例方法失败

我能修好什么，让它发挥作用？ 我已经用一个测试文件测试了我的系统是否在theano页面的GPU上工作，这是真的，所以这不可能是错误

谢谢你的帮助

罗马

Traceback (most recent call last):

  File "<ipython-input-4-f919e99b6eea>", line 1, in <module>
    if __name__== '__main__' : STARTME()

  File "C:/Users/flo9fe/Desktop/vSSGP_LVM/vssgp_example.py", line 48, in STARTME
    options={'ftol': 0, 'disp': False, 'maxiter': 500}, tol=0, callback=vssgp_opt.callback)

  File "C:\Program Files\Anaconda2\lib\site-packages\scipy\optimize\_minimize.py", line 450, in minimize
    callback=callback, **options)

  File "C:\Program Files\Anaconda2\lib\site-packages\scipy\optimize\lbfgsb.py", line 328, in _minimize_lbfgsb
    f, g = func_and_grad(x)

  File "C:\Program Files\Anaconda2\lib\site-packages\scipy\optimize\lbfgsb.py", line 278, in func_and_grad
    f = fun(x, *args)

  File "C:\Program Files\Anaconda2\lib\site-packages\scipy\optimize\optimize.py", line 292, in function_wrapper
    return function(*(wrapper_args + args))

  File "vssgp_opt.py", line 53, in func
    LL = sum(self.pool.map_async(self.eval_f_LL, arguments).get(9999999))

  File "C:\Program Files\Anaconda2\lib\multiprocessing\pool.py", line 567, in get
    raise self._value

PicklingError: Can't pickle <type 'instancemethod'>: attribute lookup __builtin__.instancemethod failed