python: Fatal IO error 11 (Resource temporarily unavailable) on X server :0.0.
Hallo quant!quant hat geschrieben:das ganze funktioniert auch wunderbar unter windows allerings unter linux bekomm ich einen fehler
Selbst die X11 Ressourcen hängen mit Berechtigungen ab. Z.b. wenn Du als Benutzer A eine Applikation auf der grafischen Oberfläche von Benutzer B laufen lassen willst.
Gerold hat geschrieben:Ansonsten: suche hier im Forum nach Threading und wx.CallAfter. Das habe ich hier schon öfter mal beschrieben.
Ich vermute mal, das soll self.em_obj.ProcessEvent sein, wx.Frame hat sowas naemlich.BlackJack hat geschrieben:Wo kommt denn `ProcessEvent` bei dem Thread her?
Code: Alles auswählen
class ThreadedAction(Thread):
def __init__(self, em_obj, **kwargs):
Thread.__init__(self, **kwargs)
self.em_obj = em_obj
def run(self):
print "Performing expensive calculation in %s..."%self.getName()
evt = NewStatusEvent()
evt.current_time = time.asctime()
while (not self.em_obj._converged and not self.em_obj.stop):
wx.CallAfter(self.em_obj.ProcessEvent, evt)
self.em_obj.iterate()
print 'done.'
Code: Alles auswählen
#
class ThreadedAction(Thread):
def __init__(self, em_obj, **kwargs):
Thread.__init__(self, **kwargs)
self.em_obj = em_obj
def run(self):
print "Performing expensive calculation in %s..."%self.getName()
while (not self.em_obj._converged and not self.em_obj.stop):
wx.CallAfter(self.em_obj)
self.em_obj.iterate()
print 'done.'
Code: Alles auswählen
# hier ist der rechen thread der iterate aufruft und danach die gui updaten soll
class ThreadedAction(Thread):
def __init__(self, em_obj, **kwargs):
Thread.__init__(self, **kwargs)
self.em_obj = em_obj
def run(self):
print "Performing expensive calculation in %s..."%self.getName()
while (not self.em_obj._converged and not self.em_obj.stop):
self.em_obj.iterate()
# give function-pointer without brackets
wx.CallAfter(self.em_obj.updateGUI)
print 'done.'
# die ganzen initialisierungen ausgelassen... jetzt kommt die klasse
class EM_MoG(wx.Frame):
#wird initialisiert usw.... dann kommt die iterate und dann die update gui
def iterate(self):
# store parameters to history-array
for t in xrange(self._theta_old.count_of_gaussians):
self._theta_history[self._counter, t] = self._theta_old.mu[t]
self._theta_history[self._counter, 2+ t] = self._theta_old.sigma[t]
self._theta_history[self._counter, 4+ t] = self._theta_old.pi[t]
# get data for y-axis of estimated pdf
self._y_em = p_x_G_theta(self._pdf_x, self._theta_old)
# TODO: add legend
#pl.legend()
# E-step
for c in xrange(self._theta_old.count_of_gaussians):
self._expectation[c, :] = p_c_G_x_theta(c, self._data, self._theta_old)
# M-step
theta_new = Theta(2)
update_mu(self._data, self._expectation, theta_new)
update_sigma(self._data, self._expectation, theta_new)
update_pi(self._data, self._expectation, theta_new)
# compute log-likelihood
# log-likelihood of initial theta is not logged because it is very low
# and the curve gets ugly ;-)
# to try including the initial theta just move this block to first line of the loop
ll = p_x_G_theta(self._data, theta_new)
ll = np.log(ll)
ll = ll.sum()
self._log_likelihood[self._counter] = ll
# check convergence
if self._counter > 0:
if self._log_likelihood[self._counter] - self._log_likelihood[self._counter-1] < self._epsilon:
# idea of Gervasio: also check if parameters don't change anymore:
if np.abs(theta_new.mu - self._theta_old.mu).max() < self._epsilon and np.abs(theta_new.sigma - self._theta_old.sigma).max() < self._epsilon and np.abs(theta_new.pi - self._theta_old.pi).max() < self._epsilon:
self._converged = True
elif self._counter >= self._max_iterations:
self._converged = True
# increment counter
self._counter += 1
# update theta
self._theta_old = theta_new
def updateGUI(self):
# plot pdf obtained by em-step
self.b.axes.plot(self._pdf_x, self._y_em)
self.canvas.draw()
# plot history of parameters (idea of Omid!!)
self.d.axes.plot(self._theta_history[:self._counter-1, :])
self.canvas.draw()
# plot history of likelihood
self.c.axes.plot(self._log_likelihood[:self._counter])
self.canvas.draw()
Code: Alles auswählen
#!/usr/bin/python
# -*- coding: utf8 -*-
######## imports ###########
#
import matplotlib
matplotlib.use("WXAgg")
matplotlib.interactive(True)
from matplotlib.backends.backend_wxagg import FigureCanvasWxAgg
from matplotlib.figure import Figure
from matplotlib.axes import Subplot
import matplotlib.pyplot as plt
import numpy as np
import pylab as pl
import math
import wx
from threading import Thread
import threading
import time
#
###########################
wx.SetDefaultPyEncoding("iso-8859-15")
class ThreadedAction(Thread):
def __init__(self, em_obj, **kwargs):
Thread.__init__(self, **kwargs)
self.em_obj = em_obj
def run(self):
print "Performing expensive calculation in %s..."%self.getName()
while (not self.em_obj._converged and not self.em_obj.stop):
self.em_obj.iterate()
# er soll iterieren und nach jedem iterationsschritt mir die grafiken updaten
wx.CallAfter(self.em_obj.updateGUI)
####################################################################################
#
class EM_MoG(wx.Frame):
def __init__(self, task):
wx.Frame.__init__(self, None, -1, "Interactive Frame v1.0")
self.fig = Figure((10,10), 75)
self.canvas = FigureCanvasWxAgg(self, -1, self.fig)
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.canvas, 1, wx.TOP)
##############################################################################
# hier werden die 4 grafiken initialisiert
self.a = self.fig.add_subplot(221)
#self.a.axes.plot(self._pdf_x, self._y_gen)
# initialisiere die plot-frames
self.b = self.fig.add_subplot(223)
self.c = self.fig.add_subplot(222)
self.d = self.fig.add_subplot(224)
################### Controller ######################
#
# create start/stop buttons
self.button_start = wx.Button(self,-1, " Start ", size=(-1,-1))
self.button_stop = wx.Button(self,-1, " Stop ", size=(-1,-1))
self.button_exit = wx.Button(self,-1, " Exit ", size=(-1,-1))
self.cb1 = wx.CheckBox(self, -1, "Show title" )
# bind actions to the buttons
self.button_start.Bind(wx.EVT_BUTTON,self.OnStart)
self.button_stop.Bind(wx.EVT_BUTTON, self.OnStop)
self.button_exit.Bind(wx.EVT_BUTTON, self.OnExit)
# pack the buttons in the Sizer
btnsizer = wx.BoxSizer(wx.HORIZONTAL)
btnsizer.Add(self.button_start, 1, wx.LEFT)
btnsizer.Add(self.button_stop, 1, wx.LEFT)
btnsizer.Add(self.button_exit, 1, wx.RIGHT)
btnsizer1 = wx.BoxSizer(wx.VERTICAL)
btnsizer1.Add(self.cb1, 1, wx.DOWN)
sizer.Add(btnsizer, 0, wx.TOP)
sizer.Add(btnsizer1, 0, wx.TOP)
self.SetSizer(sizer)
self.Fit()
#
#####################################################
# create stop-flag for multithreading
self.stop = False
def iterate(self):
# hier kommt die iteration welche aus dem thread aufgerufen wird...
pass
def updateGUI(self):
# hier soll das interface updated werden, wird aufgerufen mit callafter
# plot pdf obtained by em-step
#self.canvas.draw()
#self.b.axes.plot(self._pdf_x, self._y_em)
#print 'udone.'
# plot history of parameters (idea of Omid!!)
#self.d.axes.plot(self._theta_history[:self._counter-1, :])
#self.canvas.draw()
# plot history of likelihood
#self.c.axes.plot(self._log_likelihood[:self._counter])
#self.canvas.draw()
#self.canvas.Refresh()
#self.canvas.Update()
pass
def OnStop(self,event=None):
pass
def OnStart(self,event=None):
self.stop = False
action = ThreadedAction(self)
action.start()
def OnExit(self,event=None):
self.Destroy()
def iterate_until_converged(self):
while (not self._converged):
self.iterate()
if __name__ == '__main__':
app = wx.PySimpleApp(0)
frame = EM_MoG('d')
frame.Show(True)
app.MainLoop()
