使用 Pyside2 QThread 线程时 Scipy curve_fit 崩溃

Question

I'm using pyside2 to make a QT5 application where I'm fitting thousands of functions with scipy.optimize.curve_fit. To avoid freezing the gui I'm using Qthread() to put these thousands of calls to curve_fit on a separate thread. Sometimes this works, but if I run this program repeatedly it will occasionally crash on one of the calls to curve_fit.

I created a minimal example that can reproduce this error. Sometimes I have to run it 20 times before it crashes. The errors are: "Segmentation fault: 11" and "Process finished with exit code 139 (interrupted by signal 11: SIGSEGV)"

I'm on Python 3.8.2 with all libraries updated.

import sys
from PySide2.QtWidgets import QApplication, QLabel, QMainWindow
from PySide2.QtCore import Qt, QThread, QObject, Signal
import numpy as np
from scipy.optimize import curve_fit

class ProcessData(QObject):
    loaded = Signal(int)
    ready = Signal(list)
    finished = Signal()

    def __init__(self, data):
        super().__init__()
        self._data = data

    def func(self, x, a, b, c):
        return a * np.exp(-b * x) + c

    def run(self):
        result = []
        y = self.func(self._data, 2.5, 1.3, 0.5)
        for i in range(1000):
            y_noise = 0.2 * np.random.normal(size=self._data.size)
            ydata = y + y_noise
            print("start fit: {}".format(i))
            popt, pcov = curve_fit(self.func, self._data, ydata)
            print("finished fit: {}".format(i))
            result.append(popt)
        self.ready.emit(result)
        self.finished.emit()

    def stop(self):
        self._stop = True

class MainWindow(QMainWindow):

    def __init__(self, *args, **kwargs):
        super(MainWindow, self).__init__(*args, **kwargs)
        self.setWindowTitle("Test Application")
        self.thread = QThread()
        self.data = np.linspace(0, 4, 50)
        self.process_data = ProcessData(self.data)
        self.process_data.moveToThread(self.thread)
        self.process_data.ready.connect(self.show_result)
        self.process_data.finished.connect(self.thread.quit)
        self.thread.started.connect(self.process_data.run)
        self.thread.finished.connect(self.process_data.deleteLater)
        self.thread.start()

    def show_result(self, result):
        label = QLabel("Fitted {} functions".format(len(result)))
        label.setAlignment(Qt.AlignCenter)
        self.setCentralWidget(label)


app = QApplication(sys.argv)
window = MainWindow()
window.show()
app.exec_()

Answer 1

Disclaimer: I could not reproduce the issue.

As far as I know scipy.optimize.curve_fit uses scipy.optimize.leastsq under the hood, which is not thread-safe, and you should acquire thread lock before calling curve_fit (however it might break your purpose). The segmentation fault is also a sign that something's wrong with memory management, probably reading data that's not mapped in the process. You could try multiprocessing, but I don't think that would make anything better (since you're making a GUI).