TensorRT 6.xxx - डीप लर्निंग मॉडल (ऑब्जेक्ट डिटेक्शन और सेगमेंटेशन) के लिए उच्च प्रदर्शन

यह केवल पहली बार दर्द होता है!

सभी को नमस्कार! प्रिय दोस्तों, इस लेख में मैं Gensub.com/aidonchuk/retinanet-examples रिपॉजिटरी पर आधारित TensorRT, RetinaNet का उपयोग करने के अपने अनुभव को साझा करना चाहता हूं (यह एनवीडिया के लिए आधिकारिक टर्नकी का एक कांटा है, जो हमें उत्पादन में अनुकूलित मॉडल का उपयोग जल्द से जल्द शुरू करने की अनुमति देगा)। ओडेसाई सामुदायिक चैनलों के माध्यम से स्क्रॉल करते हुए , मैं TensorRT का उपयोग करने के बारे में सवालों के घेरे में आता हूं, और ज्यादातर प्रश्न दोहराए जाते हैं, इसलिए मैंने TensorRT, रेटिनानेट, यूनेट और डॉकटर के आधार पर तेजी से बचाव का उपयोग करने के लिए यथासंभव व्यापक मार्गदर्शिका लिखने का फैसला किया।

कार्य विवरण

मैं इस तरह से कार्य को निर्धारित करने का प्रस्ताव करता हूं: हमें डेटासेट को चिह्नित करने की आवश्यकता है, रेटिनानेट / यूनेट नेटवर्क को पाइटोरच 1.3 + पर प्रशिक्षित करें, प्राप्त वजन को ONNX में परिवर्तित करें, फिर उन्हें TensorRet इंजन में परिवर्तित करें और इस पूरे काम को docker में चलाएं, अधिमानतः Ubuntu 18 और अत्यंत एआरएम (जेटसन) * आर्किटेक्चर पर अधिमानतः, जिससे पर्यावरण की मैन्युअल तैनाती को कम किया जा सकता है। नतीजतन, हम न केवल रेटिनानेट / यूनेट के निर्यात और प्रशिक्षण के लिए एक कंटेनर तैयार करेंगे, बल्कि सभी आवश्यक बाइंडिंग के साथ वर्गीकरण, विभाजन के पूर्ण विकास और प्रशिक्षण के लिए भी तैयार होंगे।

चरण 1. पर्यावरण की तैयारी

यहां यह नोट करना महत्वपूर्ण है कि हाल ही में मैंने डेस्कटॉप मशीन पर कम से कम कुछ पुस्तकालयों के उपयोग और तैनाती को पूरी तरह से छोड़ दिया है, साथ ही साथ डिबक्स पर भी। केवल एक चीज जिसे आपको बनाना और स्थापित करना है वह है अजगर आभासी वातावरण और क्यूडा 10.2 (आप अपने आप को एकल एनवीडिया चालक तक सीमित कर सकते हैं)।

मान लीजिए कि आपके पास एक नया स्थापित उबंटू 18 है। क्यूडा 10.2 (डिब) स्थापित करें, मैं स्थापना प्रक्रिया पर विस्तार से ध्यान नहीं दूंगा, आधिकारिक दस्तावेज काफी पर्याप्त है।

अब डॉकटर स्थापित करें, डॉक इंस्टॉलेशन गाइड आसानी से पाया जा सकता है, यहां एक उदाहरण है www.digitalocean.com/community/tutorials/docker-ubuntu-18-04-1-en , 19+ संस्करण पहले से ही उपलब्ध है - इसे रखें। खैर, बिना सूदो के डॉक का उपयोग करना संभव न भूलें, यह अधिक सुविधाजनक होगा। सब कुछ बदल जाने के बाद, हम इस तरह करते हैं:

distribution=$(. /etc/os-release;echo $ID$VERSION_ID) curl -s -L https://nvidia.imtqy.com/nvidia-docker/gpgkey | sudo apt-key add - curl -s -L https://nvidia.imtqy.com/nvidia-docker/$distribution/nvidia-docker.list | sudo tee /etc/apt/sources.list.d/nvidia-docker.list sudo apt-get update && sudo apt-get install -y nvidia-container-toolkit sudo systemctl restart docker 

और आपको आधिकारिक रिपॉजिटरी github.com/NVodia/nvidia-docker पर भी ध्यान नहीं देना है ।

अब git क्लोन github.com/aidonchuk/retinanet-examples करें ।

यह सिर्फ एक छोटा सा अवशेष है, एनवीडिया-छवि के साथ डॉकटर का उपयोग शुरू करने के लिए, हमें एनजीसी क्लाउड में पंजीकरण करने और लॉग इन करने की आवश्यकता है। हम यहां जाते हैं ngc.nvidia.com , रजिस्टर करें और हम NGC क्लाउड के अंदर जाने के बाद, स्क्रीन के ऊपरी बाएं कोने में SETUP दबाएं या इस लिंक का अनुसरण करें ngc.nvidia.com/setup/api-key । "जनरेट कुंजी" पर क्लिक करें। मैं इसे बचाने की सलाह देता हूं, अन्यथा अगली बार जब आप इसे देखते हैं, तो आपको इसे फिर से बनाना होगा और, तदनुसार, इसे एक नए व्हीलब्रो पर तैनात करते हुए, इस ऑपरेशन को दोहराएं।

पूरा हुआ:

 docker login nvcr.io Username: $oauthtoken Password: <Your Key> -   

उपयोगकर्ता नाम सिर्फ कॉपी। खैर, विचार करें, पर्यावरण तैनात है!

चरण 2. डॉकटर कंटेनर को असेंबल करना

हमारे काम के दूसरे चरण में, हम डॉकटर को इकट्ठा करेंगे और इसके इनसाइड से परिचित होंगे।
आइए रेटिना-उदाहरण परियोजना के सापेक्ष रूट फ़ोल्डर पर जाएं और चलाएं

 docker build --build-arg USER=$USER --build-arg UID=$UID --build-arg GID=$GID --build-arg PW=alex -t retinanet:latest retinanet/ 

हम वर्तमान उपयोगकर्ता को इसमें फेंककर डॉकटर इकट्ठा करते हैं - यह बहुत उपयोगी है यदि आप वर्तमान उपयोगकर्ता के अधिकारों के साथ घुड़सवार VOLUME पर कुछ लिखते हैं, अन्यथा जड़ और दर्द होगा।

डॉकटर जा रहा है, चलो डॉकफाइल का अन्वेषण करें:

 FROM nvcr.io/nvidia/pytorch:19.10-py3 ARG USER=alex ARG UID=1000 ARG GID=1000 ARG PW=alex RUN useradd -m ${USER} --uid=${UID} && echo "${USER}:${PW}" | chpasswd RUN apt-get -y update && apt-get -y upgrade && apt-get -y install curl && apt-get -y install wget && apt-get -y install git && apt-get -y install automake && apt-get install -y sudo && adduser ${USER} sudo RUN pip install git+https://github.com/bonlime/pytorch-tools.git@master COPY . retinanet/ RUN pip install --no-cache-dir -e retinanet/ RUN pip install /workspace/retinanet/extras/tensorrt-6.0.1.5-cp36-none-linux_x86_64.whl RUN pip install tensorboardx RUN pip install albumentations RUN pip install setproctitle RUN pip install paramiko RUN pip install flask RUN pip install mem_top RUN pip install arrow RUN pip install pycuda RUN pip install torchvision RUN pip install pretrainedmodels RUN pip install efficientnet-pytorch RUN pip install git+https://github.com/qubvel/segmentation_models.pytorch RUN pip install pytorch_toolbelt RUN chown -R ${USER}:${USER} retinanet/ RUN cd /workspace/retinanet/extras/cppapi && mkdir build && cd build && cmake -DCMAKE_CUDA_FLAGS="--expt-extended-lambda -std=c++14" .. && make && cd /workspace RUN apt-get install -y openssh-server && apt install -y tmux && apt-get -y install bison flex && apt-cache search pcre && apt-get -y install net-tools && apt-get -y install nmap RUN apt-get -y install libpcre3 libpcre3-dev && apt-get -y install iputils-ping RUN mkdir /var/run/sshd RUN echo 'root:pass' | chpasswd RUN sed -i 's/PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config RUN sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd ENV NOTVISIBLE "in users profile" RUN echo "export VISIBLE=now" >> /etc/profile CMD ["/usr/sbin/sshd", "-D"] 

जैसा कि आप पाठ से देख सकते हैं, हम अपने सभी पसंदीदा लोगों को लेते हैं, रेटिनानेट संकलित करते हैं, उबंटू के साथ काम करने की सुविधा के लिए बुनियादी उपकरण वितरित करते हैं, और ओपनश सर्वर को कॉन्फ़िगर करते हैं। पहली पंक्ति सिर्फ एनवीडिया इमेज की विरासत है, जिसके लिए हमने NGC क्लाउड में एक लॉगिन बनाया और जिसमें Pytorch1.3, TensorRT6.xxx और कामेच्छा का एक समूह शामिल है जो हमें अपने डिटेक्टर के लिए cpp स्रोत कोड संकलित करने की अनुमति देता है।

स्टेज 3. डॉकटर कंटेनर को शुरू करना और डिबग करना

चलो कंटेनर और विकास पर्यावरण का उपयोग करने के मुख्य मामले पर चलते हैं, शुरू करने के लिए, एनवीडिया डॉकर चलाते हैं। पूरा हुआ:

 docker run --gpus all --net=host -v /home/<your_user_name>:/workspace/mounted_vol -d -P --rm --ipc=host -it retinanet:latest 

अब कंटेनर ssh <curr_user_name> @localhost पर उपलब्ध है। एक सफल लॉन्च के बाद, PyCharm में प्रोजेक्ट खोलें। अगला, खुला

 Settings->Project Interpreter->Add->Ssh Interpreter 

चरण 1


चरण 2


चरण 3


हम स्क्रीनशॉट के रूप में सब कुछ का चयन करें,

 Interpreter -> /opt/conda/bin/python 

- यह Python3.6 में ln होगा और

 Sync folder -> /workspace/retinanet 

हम फिनिश लाइन दबाते हैं, हम इंडेक्सिंग की उम्मीद करते हैं, और यह है, पर्यावरण उपयोग के लिए तैयार है!

महत्वपूर्ण !!! अनुक्रमण के तुरंत बाद, डॉकटर से रेटिनानेट के लिए संकलित फ़ाइलों को निकालें। प्रोजेक्ट रूट में संदर्भ मेनू में, चयन करें

 Deployment->Download 

एक फाइल और दो बिल्ड फोल्डर, retinanet.egg-info और _so दिखाई देंगे



यदि आपका प्रोजेक्ट इस तरह दिखता है, तो पर्यावरण सभी आवश्यक फाइलों को देखता है और हम रेटिनानेट सीखने के लिए तैयार हैं।

चरण 4. डेटा को चिह्नित करना और डिटेक्टर को प्रशिक्षित करना

मार्कअप के लिए, मैं मुख्य रूप से पर्यवेक्षण का उपयोग करता हूं। एक अच्छा और सुविधाजनक उपकरण, आखिरी समय में जाम का एक गुच्छा तय किया गया था और यह बहुत अच्छा व्यवहार बन गया।

मान लीजिए कि आपने एक डेटासेट को चिह्नित किया है और इसे डाउनलोड किया है, लेकिन इसे तुरंत हमारे रेटिनानेट में डालने के लिए काम नहीं किया है, क्योंकि यह अपने स्वयं के प्रारूप में है और इसके लिए हमें इसे COCO में बदलने की आवश्यकता है। रूपांतरण उपकरण इस प्रकार है:

 markup_utils/supervisly_to_coco.py 

कृपया ध्यान दें कि स्क्रिप्ट में श्रेणी एक उदाहरण है और आपको अपनी खुद की सम्मिलित करने की आवश्यकता है (आपको पृष्ठभूमि श्रेणी जोड़ने की आवश्यकता नहीं है)

 categories = [{'id': 1, 'name': '1'}, {'id': 2, 'name': '2'}, {'id': 3, 'name': '3'}, {'id': 4, 'name': '4'}] 

किसी कारण से, मूल रिपॉजिटरी के लेखकों ने फैसला किया कि आप डिटेक्शन के लिए COCO / VOC को छोड़कर कुछ भी प्रशिक्षित नहीं करेंगे, इसलिए मुझे स्रोत फ़ाइल को थोड़ा संशोधित करना पड़ा

 retinanet/dataset.py 

टुट्डा को जोड़कर अपने पसंदीदा वृद्धि अल्बुमेंटेशन.्रेडथेडोक्स.आईएन / लेटेस्ट और हार्ड-वायर्ड श्रेणियों को सीओसीओ से बाहर कर दें। यदि आप बड़े चित्रों में छोटी वस्तुओं की तलाश कर रहे हैं, तो आपके पास एक छोटा डेटासेट है =), और कुछ भी काम नहीं करता है, लेकिन उस समय पर और भी बहुत कुछ पता लगाना संभव है।

सामान्य तौर पर, ट्रेन का लूप भी कमजोर होता है, शुरू में यह चौकियों को नहीं बचाता था, यह कुछ भयानक शेड्यूलर आदि का उपयोग करता था। लेकिन अब आपको केवल बैकबोन का चयन करना है और निष्पादित करना है

 /opt/conda/bin/python retinanet/main.py 

मापदंडों के साथ:

 train retinanet_rn34fpn.pth --backbone ResNet34FPN --classes 12 --val-iters 10 --images /workspace/mounted_vol/dataset/train/images --annotations /workspace/mounted_vol/dataset/train_12_class.json --val-images /workspace/mounted_vol/dataset/test/images_small --val-annotations /workspace/mounted_vol/dataset/val_10_class_cropped.json --jitter 256 512 --max-size 512 --batch 32 

कंसोल में आप देखेंगे:

 Initializing model... model: RetinaNet backbone: ResNet18FPN classes: 2, anchors: 9 Selected optimization level O0: Pure FP32 training. Defaults for this optimization level are: enabled : True opt_level : O0 cast_model_type : torch.float32 patch_torch_functions : False keep_batchnorm_fp32 : None master_weights : False loss_scale : 1.0 Processing user overrides (additional kwargs that are not None)... After processing overrides, optimization options are: enabled : True opt_level : O0 cast_model_type : torch.float32 patch_torch_functions : False keep_batchnorm_fp32 : None master_weights : False loss_scale : 128.0 Preparing dataset... loader: pytorch resize: [1024, 1280], max: 1280 device: 4 gpus batch: 4, precision: mixed Training model for 20000 iterations... [ 1/20000] focal loss: 0.95619, box loss: 0.51584, 4.042s/4-batch (fw: 0.698s, bw: 0.459s), 1.0 im/s, lr: 0.0001 [ 12/20000] focal loss: 0.76191, box loss: 0.31794, 0.187s/4-batch (fw: 0.055s, bw: 0.133s), 21.4 im/s, lr: 0.0001 [ 24/20000] focal loss: 0.65036, box loss: 0.30269, 0.173s/4-batch (fw: 0.045s, bw: 0.128s), 23.1 im/s, lr: 0.0001 [ 36/20000] focal loss: 0.46425, box loss: 0.23141, 0.178s/4-batch (fw: 0.047s, bw: 0.131s), 22.4 im/s, lr: 0.0001 [ 48/20000] focal loss: 0.45115, box loss: 0.23505, 0.180s/4-batch (fw: 0.047s, bw: 0.133s), 22.2 im/s, lr: 0.0001 [ 59/20000] focal loss: 0.38958, box loss: 0.25373, 0.184s/4-batch (fw: 0.049s, bw: 0.134s), 21.8 im/s, lr: 0.0001 [ 71/20000] focal loss: 0.37733, box loss: 0.23988, 0.174s/4-batch (fw: 0.049s, bw: 0.125s), 22.9 im/s, lr: 0.0001 [ 83/20000] focal loss: 0.39514, box loss: 0.23878, 0.181s/4-batch (fw: 0.048s, bw: 0.133s), 22.1 im/s, lr: 0.0001 [ 94/20000] focal loss: 0.39947, box loss: 0.23817, 0.185s/4-batch (fw: 0.050s, bw: 0.134s), 21.6 im/s, lr: 0.0001 [ 105/20000] focal loss: 0.37343, box loss: 0.20238, 0.182s/4-batch (fw: 0.048s, bw: 0.134s), 22.0 im/s, lr: 0.0001 [ 116/20000] focal loss: 0.19689, box loss: 0.17371, 0.183s/4-batch (fw: 0.050s, bw: 0.132s), 21.8 im/s, lr: 0.0001 [ 128/20000] focal loss: 0.20368, box loss: 0.16538, 0.178s/4-batch (fw: 0.046s, bw: 0.131s), 22.5 im/s, lr: 0.0001 [ 140/20000] focal loss: 0.22763, box loss: 0.15772, 0.176s/4-batch (fw: 0.050s, bw: 0.126s), 22.7 im/s, lr: 0.0001 [ 148/20000] focal loss: 0.21997, box loss: 0.18400, 0.585s/4-batch (fw: 0.047s, bw: 0.144s), 6.8 im/s, lr: 0.0001 Average Precision (AP) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.52674 Average Precision (AP) @[ IoU=0.50 | area= all | maxDets=100 ] = 0.91450 Average Precision (AP) @[ IoU=0.75 | area= all | maxDets=100 ] = 0.35172 Average Precision (AP) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.61881 Average Precision (AP) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.00000 Average Precision (AP) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = -1.00000 Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 1 ] = 0.58824 Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets= 10 ] = 0.61765 Average Recall (AR) @[ IoU=0.50:0.95 | area= all | maxDets=100 ] = 0.61765 Average Recall (AR) @[ IoU=0.50:0.95 | area= small | maxDets=100 ] = 0.61765 Average Recall (AR) @[ IoU=0.50:0.95 | area=medium | maxDets=100 ] = -1.00000 Average Recall (AR) @[ IoU=0.50:0.95 | area= large | maxDets=100 ] = -1.00000 Saving model: 148 

मापदंडों के पूरे सेट का अध्ययन करने के लिए देखो

 retinanet/main.py 

सामान्य तौर पर, वे पता लगाने के लिए मानक होते हैं, और उनका विवरण होता है। प्रशिक्षण चलाएं और परिणामों की प्रतीक्षा करें। अनुमान का एक उदाहरण इसमें पाया जा सकता है:

 retinanet/infer_example.py 

या कमांड निष्पादित करें:

 /opt/conda/bin/python retinanet/main.py infer retinanet_rn34fpn.pth --images /workspace/mounted_vol/dataset/test/images --annotations /workspace/mounted_vol/dataset/val.json --output result.json --resize 256 --max-size 512 --batch 32 

फोकल लॉस और कई बैकबोन पहले से ही रिपॉजिटरी में निर्मित हैं, और उनके

 retinanet/backbones/*.py 

लेखक नेमप्लेट में कुछ विशेषताएं देते हैं:



टार्चविजन से लिया गया एक बैकबोन ResNeXt50_32x4dFPN और ResNeXt101_32x8dFPN भी है।
मुझे उम्मीद है कि हमने पता लगा लिया है, लेकिन आपको निर्यात और लॉगिंग मोड को समझने के लिए आधिकारिक दस्तावेज को जरूर पढ़ना चाहिए।

चरण 5. Resnet एनकोडर के साथ Unet मॉडल का निर्यात और निष्कासन

जैसा कि आपने शायद देखा था, डॉकफेरील में विभाजन के लिए पुस्तकालय स्थापित किए गए थे, और विशेष रूप से अद्भुत पुस्तकालय github.com/qubvel/seactation_models.pytorch । आप यूनेट पैकेज में TensorRT इंजन में पाइरॉच चौकियों के आक्रमण और निर्यात के उदाहरण पा सकते हैं।

ONNX से TensoRT तक यूनेट जैसे मॉडल निर्यात करते समय मुख्य समस्या यह है कि एक निश्चित अपसप्ले आकार निर्धारित किया जाए या ConvTranspose2D का उपयोग किया जाए:

 import torch.onnx.symbolic_opset9 as onnx_symbolic def upsample_nearest2d(g, input, output_size): # Currently, TRT 5.1/6.0 ONNX Parser does not support all ONNX ops # needed to support dynamic upsampling ONNX forumlation # Here we hardcode scale=2 as a temporary workaround scales = g.op("Constant", value_t=torch.tensor([1., 1., 2., 2.])) return g.op("Upsample", input, scales, mode_s="nearest") onnx_symbolic.upsample_nearest2d = upsample_nearest2d 

इस रूपांतरण का उपयोग करते हुए, आप ONNX को निर्यात करते समय स्वचालित रूप से ऐसा कर सकते हैं, लेकिन पहले से ही TensorRT के संस्करण 7 में यह समस्या हल हो गई थी, और हमें बहुत कम इंतजार करना पड़ा।

निष्कर्ष

जब मैंने डॉकटर का उपयोग करना शुरू किया, मुझे अपने कार्यों के लिए इसके प्रदर्शन के बारे में संदेह था। मेरी एक इकाई में, अब कई कैमरों द्वारा बनाया गया नेटवर्क ट्रैफ़िक काफी है।



इंटरनेट पर विभिन्न परीक्षणों ने VOLUME पर नेटवर्क इंटरेक्शन और रिकॉर्डिंग के लिए एक अपेक्षाकृत बड़े ओवरहेड का खुलासा किया, साथ ही एक अज्ञात और भयानक जीआईएल, और एक फ्रेम की शूटिंग के बाद से, चालक ऑपरेशन और एक नेटवर्क पर एक फ्रेम को प्रसारित करना कठिन वास्तविक समय मोड में परमाणु संचालन हैं, देरी ऑनलाइन मेरे लिए बहुत महत्वपूर्ण हैं।

लेकिन कुछ भी नहीं हुआ =)

पुनश्च यह विभाजन और उत्पादन के लिए अपने पसंदीदा ट्रेन लूप को जोड़ने के लिए बनी हुई है!

Blagodranosti

ओडेसाई समुदाय के लिए धन्यवाद, इसके बिना विकास करना असंभव है! N01z3 , DL के लिए बहुत-बहुत धन्यवाद, जिन्होंने मुझे अपनी अमूल्य सलाह और असाधारण व्यावसायिकता के लिए DL लेने की कामना की!

उत्पादन में अनुकूलित मॉडल का उपयोग करें!

औरोराय, llc