Das deutsche Python-Forum

Du hast doch 'Im Grunde alles nach den Importen.' einige Posts zuvor geschrieben.
Im Post davor habe ich dir VSSGP_opt zitiert, also gehe ich davon aus, dass du dieses Modul meinst, aber eben alles ab Zeile 11,12 (eingeschlossen), wenn ich es hier noch einmal poste:

[codebox=python file=Unbenannt.txt] import numpy as np
from vssgp_model import VSSGP
import pylab
import multiprocessing
def extend(x, y, z = {}):
return dict(x.items() + y.items() + z.items())
def eval_f_LL(X, Y, params):
out_f = VSSGP.f['LL'](**extend({'X': X, 'Y': Y}, params))
return out_f
def eval_g_LL(name, X, Y, params):
out_g = VSSGP.f['LL'](**extend({'X': X, 'Y': Y}, params))
return out_g

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 unpack(self, x):
x_param_values = [x[self.sizes[i-1]:self.sizes].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 = 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(eval_f_LL, arguments).get(9999999))
KL = self.vssgp.f['KL'](**extend({'X': [[0]], 'Y': [[0]]}, params))
else:
split = np.random.randint(splits)
LL = self.N / self.batch_size * self.vssgp.f['LL'](**extend({'X': X[split::splits], 'Y': Y[split::splits]}, params))
print(LL)
KL = self.vssgp.f['KL'](**extend({'X': [[0]], 'Y': [[0]]}, params))
else:
params = 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 = [], 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(eval_g_LL, arguments).get(9999999))
dKL = self.vssgp.g[n]['KL'](**extend({'X': [[0]], 'Y': [[0]]}, params))
else:
split = np.random.randint(splits)
dLL = self.N / self.batch_size * self.vssgp.g[n]['LL'](**extend({'X': X[split::splits], 'Y': Y[split::splits]}, params))
dKL = self.vssgp.g[n]['KL'](**extend({'X': [[0]], 'Y': [[0]]}, params))
else:
params = 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 = 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[/code]

Und den Post danach schreibst du ' Nochmal: Das ist das falsche Modul!', nachdem ich dir eine vermeintlich trivialen Versuch einer Lösung liefere. Sorry aber ich verstehe es einfach nicht. DU könntest mir sehr helfen, wenn du einfach konkret wirst, indem du mir im Code zeigst, was du als das Modul meinst, weil anscheinend ist es ja schon da, da du schreibst 'Du führst doch nur eines davon als Programm aus'.
Nicht falsch verstehen, ich möchte wirklich etwas lernen...

Üblicherweise erstellst du ein zweites Programm, in dem du dann dieses importieren würdest.. Hast du sowas etwa nicht?

In Post 'Mittwoch 15. Februar 2017, 13:16' habe ich alles zitiert, was ich habe, bis auf die Theano-Funktionen, die compiliert werden bzw. geladen werden.
Auch in Post 'Sonntag 12. Februar 2017, 17:43' habe ich auf die Demo verlinkt.

@Romaxx: Ja, das Modul das Du als Programm ausführst ist schon da. Sonst hättest Du die Fehlermeldungen ja nicht zeigen können die beim Ausführen aufgetreten sind. Und wenn Du jetzt fragst welches Modul das ist, welches Du ausgeführt hast… Ähm, diese Frage kann man gar nicht ernsthaft stellen.

Ich weiss nicht, wie man als Helfer einfach konsequent fast durchgehend meine postings nicht für Ernst nehmen kann...
Das ist meine Antwort dazu.

Danke für deine Hilfe bis hierher.

Vielleicht gibt jemanden, der mir einfach konkret sagen kann, um welches Modul es sich handelt. Danke.

@Romaxx: Ich verstehe Deine Frage nach dem Modul nicht, nachdem ich mehrfach dazu Antworten geschrieben habe. Und wenn Du ein Modul ausführst und danach fragst welches Modul ich meine wenn ich sage das Modul das man als Programm ausführt, dann kann das meiner Meinung nicht sein das jemand diese Frage stellt. Das geht einfach nicht. Du hast das Modul ausgeführt, mehrfach, es ist in der README beschrieben welches Modul man ausführen muss, das hast Du getan, und Du fragst ernsthaft welches Modul ich meine? Und kommst immer wieder mit dem gleichen falschen Modul angedackelt, obwohl ich mehrfach gesagt habe das ist es nicht, sondern das welches als Programm ausgeführt wurde. Selbst wenn Du nicht wissen solltest welches das war, was gar nicht sein kann, kannst Du doch nicht immer wieder mit dem falschen Modul ankommen. Du verarschst mich hier doch, wie soll ich das noch ernst nehmen?

Ja klar, und ich hab den ganzen Tag nichts besseres zu tun, als in Foren hilfsbereite Menschen zu verarschen.
Du hast mir ja bisher auch noch keine andere Antwort geliefert, als 'das Modul, welches als Programm ausgeführt wird'. Sorry, aber wie kannst du dann erwarten, dass ich weiter komme mit dieser Sache hier. Außerdem habe ich dir mehrfach auch andere mögliche Ideen genannt, aber leider ist raten und dann ins Schwarze treffen nicht immer von Erfolg gekrönt.
Dein Weltbild in allen Ehren...
Ich belasse das jetzt hiermit.

@Romaxx: Wo hast Du was anderes geraten? Und falls Du das hättest: Bei drei Modulen schaffst Du durch mehrfaches raten nicht das richtige zu finden? Und ich habe Dir das Modul genannt. Und welche Zeilen betroffen sind. Wenn Leseverständnis nicht Dein Ding ist, dann ist das hier das falsche Forum. Andererseits kannst Du eigentlich nur ein Troll sein. Du hast das Programm gestartet und kannst nicht sagen welches Modul Du da als Programm gestartet hast — diese Aussage ist schlicht nicht realistisch.

Da bin ich wieder.
Ich habe nun vssgp_example zum Teil in eine Funktion gepackt:

[codebox=python file=Unbenannt.txt]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)[/code]

Und rufe danach

[codebox=python file=Unbenannt.txt]if __name__== '__main__' : STARTME()[/code]

auf.
Ich denke, das sollte nun so passen.

Das vssgp_opt modul habe ich nun zu

[codebox=python file=Unbenannt.txt]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].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

[/code]

verändert. Vor allem die globalen Variablen sind nun weg.
Nun erhalte ich aber diesen Fehler:

Hallo,

ich pushe diese Nachricht jetzt einfach mal, in der Hoffnung, dass jemand, der sich mit Theano und GPU auskennt, hier noch eine Antwort geben kann.
Falls dies nicht erlaubt ist, bitte löschen.

Grüße Romaxx

Hallo zusammen,

gibt es niemanden, der sich den Fehler vor 2 Posts mal näher anschauen kann?
Wieso kann nicht 'gepickled' werden?

Mein naives Verständnis von diesem Vorgang ist, dass python hier versucht die Berechnungen aufzuteilen und das das aus irgendeinem Grund nicht funktioniert. Wie schon gesagt sollte diese Demo aber auf einer GPU funktionieren. Ich habe auf meiner weiteren Recherche diesen Thread gefunden:
https://bytes.com/topic/python/answers/ ... ncemethods . Steven Bethard liefert glaube ich dazu eine Lösung (Kann mir das jemand bestätigen?). Nur ist mir nicht ganz klar, wie ich das übertragen kann.


Vielen Dank und Grüße.

Romaxx

Ich habe den Fehler nun mit pathos multiprocessing wegbekommen. Siehe code unten.

[codebox=python file=Unbenannt.txt]import numpy as np
from vssgp_model import VSSGP
# import multiprocessing
import pathos.multiprocessing as mp

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 = mp.ProcessingPool(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].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(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(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[/code]

Nun erhalte ich aber die Fehler:
Jemand der mit hier weiterhelfen kann?

Danke und Grüße

Ok, auch dieser Fehler scheint behoben, habe einfach

[codebox=python file=Unbenannt.txt]import pathos.multiprocessing as mp[/code]

durch

[codebox=python file=Unbenannt.txt]from pathos.pools import ThreadPool[/code]

und

[codebox=python file=Unbenannt.txt]mp.ProcessingPool[/code]

durch

[codebox=python file=Unbenannt.txt]ThreadPool[/code].

Nächster Fehler ist dies hier
Jemand der mir sagen kann, was zu verbessern ist? Danke