मैं एक मॉडल के लिए पता लगाने की दर को तेज करने के लिए मल्टीप्रोसेसिंग मॉडल का उपयोग करने की कोशिश कर रहा हूं। मैं चार कोर का उपयोग करना चाहता हूं और छवियों को क्रम में रखते हुए समानांतर तरीके से संसाधित करना चाहता हूं। जब एक प्रक्रिया को जन्म दिया जाता है, तो एक पाइप को भी तत्काल किया जाता है, बच्चे के हिस्से को प्रक्रिया में पास कर दिया जाता है जबकि माता-पिता को एक अलग कतार में रखा जाता है। स्क्रिप्ट एक EOFError फेंकता है क्योंकि मैं पाइप को पोल करने के बाद भी पैरेंट पाइप पर आरईवी विधि को कॉल करता हूं।

इस कार्यक्रम के एक सरल संस्करण में, मैंने छवि के बजाय बस "हैलो" भेजा, लेकिन एक EOFError अभी भी फेंका गया था। साथ ही, मैंने पाइप के चाइल्ड एंड को बंद किए बिना स्क्रिप्ट की कोशिश की लेकिन त्रुटि अभी भी फेंक दी गई थी

import io 
import time
import tensorflow as tf
physical_devices = tf.config.experimental.list_physical_devices('GPU')
if len(physical_devices) > 0:
    tf.config.experimental.set_memory_growth(physical_devices[0], True)
from absl import app, flags, logging
import core.utils as utils
from core.yolov4 import filter_boxes
from tensorflow.python.saved_model import tag_constants
from PIL import Image
import cv2
import numpy as np
from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSession
from queue import Queue 
from concurrent.futures import ProcessPoolExecutor
from multiprocessing import Pool, Process, Pipe

flag_rep = {
    "framework" : 'tflite',
    "weights" : './checkpoints/yolov4-tiny-416.tflite',
    "size" : 416,
    "tiny" : False,
    "model" : 'yolov4',
    "iou" : .45,
    "score" : .25,
}
vid = cv2.VideoCapture(0)
config = ConfigProto()
config.gpu_options.allow_growth = True

session = InteractiveSession(config=config)
STRIDES, ANCHORS, NUM_CLASS, XYSCALE = utils.load_config_from_dict(flag_rep)
input_size = flag_rep['size']
interpreter = tf.lite.Interpreter(model_path=flag_rep['weights'])
interpreter.allocate_tensors()
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()
i=0

def eval_im(frame, child):
    original_image = frame
    original_image = cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB)
    image_data = cv2.resize(original_image, (input_size, input_size))
    image_data = image_data / 255.
    images_data = []
    for i in range(1):
        images_data.append(image_data)
    images_data = np.asarray(images_data).astype(np.float32)
    interpreter.set_tensor(input_details[0]['index'], images_data)
    interpreter.invoke()
    pred = [interpreter.get_tensor(output_details[i]['index']) for i in range(len(output_details))]
    boxes, pred_conf = filter_boxes(pred[0], pred[1], score_threshold=0.25, input_shape=tf.constant([input_size, input_size]))
    boxes, scores, classes, valid_detections = tf.image.combined_non_max_suppression(
        boxes=tf.reshape(boxes, (tf.shape(boxes)[0], -1, 1, 4)),
        scores=tf.reshape(
            pred_conf, (tf.shape(pred_conf)[0], -1, tf.shape(pred_conf)[-1])),
        max_output_size_per_class=50,
        max_total_size=50,
        iou_threshold=flag_rep['iou'],
        score_threshold=flag_rep['score']
    )
    pred_bbox = [boxes.numpy(), scores.numpy(), classes.numpy(), valid_detections.numpy()]
    image = utils.draw_bbox(original_image, pred_bbox)

    child.send([img])
    child.close()

if __name__ == "__main__":
    processes = Queue()
    parent_pipes = Queue() 
    overflow = Queue()
    while True: 
        ret, pic = vid.read()
        overflow.put(pic)
        if processes.qsize() < 4: 
            parent, child = Pipe()
            parent_pipes.put(parent)
            process = Process(target=eval_im, args=(overflow.get(), child))
            processes.put(process)
            process.start()
        print(parent_pipes.qsize())
        if parent_pipes.queue[0].poll(): 
            process = processes.get()
            process.join()
            parent_pipe = parent_pipes.get()
            img = parent_pipe.recv()
            parent_pipe.close()
            
            # cv2.imshow("frame", img)
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break 
    vid.release()
    cv2.destroyAllWindows()

यहाँ आउटपुट है:

Traceback (most recent call last):
  File "testing_multi.py", line 89, in <module>
    img = parent_pipe.recv()
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/multiprocessing/connection.py", line 250, in recv
    buf = self._recv_bytes()
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/multiprocessing/connection.py", line 407, in _recv_bytes
    buf = self._recv(4)
  File "/Library/Frameworks/Python.framework/Versions/3.7/lib/python3.7/multiprocessing/connection.py", line 383, in _recv
    raise EOFError
EOFError
0
Rishi Gundakaram 18 अगस्त 2020, 03:16

1 उत्तर

सबसे बढ़िया उत्तर

किसी के लिए भी जो अब इस पर ठोकर खा रहा है। मुझे पता चला कि यह त्रुटि पाइथन में ग्लोबल दुभाषिया लॉक के कारण होती है। मैं उस पर इतना पढ़ा-लिखा नहीं हूं। लेकिन सार यह है कि एक समय में केवल एक धागा अजगर दुभाषिया का उपयोग कर सकता है। संगामिति और समवर्ती। फ्यूचर्स जैसे मॉड्यूल कई दुभाषियों को पैदा करके इसे प्राप्त कर सकते हैं। हालाँकि, तब डेटा को दो उदाहरणों के बीच साझा करना कठिन होता है। इस प्रकार इनमें से कुछ मॉड्यूल में पाइप और कतार जैसे उपकरण हैं जो इन उदाहरणों को संचार करने की अनुमति देते हैं। हालांकि, इन उपकरणों के लिए आवश्यक है कि वस्तुएं "अचार योग्य" हों। इस मामले में, मेरी वस्तुएं अचार करने योग्य नहीं थीं। इस प्रकार मुझे त्रुटि मिली।

1
Rishi Gundakaram 12 अक्टूबर 2020, 02:07