python - 汇总计算有时会无故超时

Question

我目前正在执行池化操作来执行并行任务。这些任务是基于 openCV 的关键点提取，使用 ORB 方法对源图像和其他 3 个不同图像之间的相似性进行评分。

我可以执行一次我的池化函数。有用。

如果我在通话后不执行任何其他操作，我可以再次拨打电话，它会再次工作。

执行时间始终相同，大约为一秒，CPU 负载行为也是如此。4 个核心的负载高达 100%，然后一秒钟后下降。

现在，如果我在这两个相同的调用之间执行类似旋转图像的操作，即使我的池化函数没有使用这个图像，它也不再起作用。

在调用时 CPU 不会加载，池化函数最终将在 100 秒后超时。

这是池化函数的代码：

def compute_pooled(source, img1, img2, img3, n_features, scale_factor, n_levels, lowe_ratio):

    pool = Pool()

    image_same        = same
    image_similar     = similar
    image_different   = different
    #confidence = get_match_confidence(image, img2)

    args_same = [image_same,source, n_features, scale_factor, n_levels, lowe_ratio]
    args_similar = [image_similar,source, n_features, scale_factor, n_levels, lowe_ratio]
    args_different = [image_different,source, n_features, scale_factor, n_levels, lowe_ratio]

    result_same = pool.apply_async(match_with_orb, args_same)
    result_similar = pool.apply_async(match_with_orb, args_similar)
    result_different = pool.apply_async(match_with_orb, args_different)

    good_same = result_same.get(timeout=100)
    good_similar = result_similar.get(timeout=100)
    good_different = result_different.get(timeout=100)

    values = [good_same, good_similar, good_different]

    ## I tried closing, terminating, not doing anything..
    pool.close()
    return values

这是每个池中被调用函数的代码：

def match_with_orb(img1, img2, n_features, scale_factor, n_levels, lowe_ratio):
    orb = cv2.ORB_create(nfeatures=n_features, scaleFactor=scale_factor, nlevels=n_levels)
    keypoints_orb1, descriptors1 = orb.detectAndCompute(img1, None)
    keypoints_orb2, descriptors2 = orb.detectAndCompute(img2, None)

    bf = cv2.BFMatcher()

    matches = bf.knnMatch(descriptors1,descriptors2, k=2)
    method='orb'

    good = []

    for m,n in matches:
        if m.distance < lowe_ratio*n.distance:
            good.append([m])

    return len(good)

如果我执行以下说明一切正常：

import numpy as np
import cv2
from matplotlib import pyplot as plt
from pathlib import Path
from multiprocessing import Pool, cpu_count

imgname_source = 'source.jpg'
img1 = 'img1.jpg'
img2 = 'img2.jpg'
img3 = 'img3.jpg'

dirPath = '/home/path/to/imgs/'

source     = cv2.imread(dirPath+imgname_source,0)
_img1       = cv2.imread(dirPath+img1,0)
_img2    = cv2.imread(dirPath+img2,0)
_img3  = cv2.imread(dirPath+img3,0)

compute_pooled(source, _img1, _img2, _img3, 5000, 1.15, 16, 0.67)

在 100% cpu 负载下，它会在不到一秒的时间内自行执行。如果我再次调用 compute_pooled 函数，它的工作方式相同。

现在，使用以下功能：

def rotate(image, angle, center=None, scale=1.0):
    (h, w) = image.shape[:2]
    if center is None:
        center = (w // 2, h // 2)
    M = cv2.getRotationMatrix2D(center, angle, scale)
    rotated = cv2.warpAffine(image, M, (w, h))
    return rotated

如果我在两个 compute_pooled 调用之间调用它，即使在当前使用的图像之外的其他图像上，第二个 compute_pooled 调用也将不起作用。

## First call works
compute_pooled(source, _img1, _img2, _img3, 5000, 1.15, 16, 0.67) 
_img4 = rotate(_img1, 90)
## Second call times out
compute_pooled(source, _img1, _img2, _img3, 5000, 1.15, 16, 0.67) 

这里有什么问题？我完全不明白为什么第二次调用超时而没有启动任何计算。

这是错误。它超时无法从第一个 .get() 调用中检索任何结果。

--> 223     good_same = result_same.get(timeout=100)
    224     good_similar = result_similar.get(timeout=100)
    225     good_different = result_different.get(timeout=100)

~/anaconda3/lib/python3.7/multiprocessing/pool.py in get(self, timeout)
    651         self.wait(timeout)
    652         if not self.ready():
--> 653             raise TimeoutError
    654         if self._success:
    655             return self._value

TimeoutError: 

标签： pythonpython-3.xmultithreadingopencvpool