उद्योग और अनुसंधान दोनों में लोकप्रिय मशीन लर्निंग (एमएल) के लिए मानक मंच बन गया है। एमएल मॉडल के प्रशिक्षण और रखरखाव के लिए कई मुफ्त पुस्तकालय, उपकरण और रूपरेखा बनाई गई हैं। Tensorflow सर्विंग प्रोजेक्ट एक वितरित उत्पादन वातावरण में एमएल मॉडल को बनाए रखने में मदद करता है।

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

Tensorflow की सेवा क्या है?

Tensorflow सर्विंग एमएल मॉडल को तैनात करने और बनाए रखने के लिए एक लचीला सर्वर आर्किटेक्चर प्रदान करता है। एक बार जब मॉडल को प्रशिक्षित किया जाता है और पूर्वानुमान के लिए उपयोग करने के लिए तैयार होता है, तो टेंसरफ़्लो सर्विंग को इसे एक संगत (सर्विसेबल) प्रारूप में निर्यात करने की आवश्यकता होती है।

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



Tensorflow Serving एक GRPC / HTTP सर्वर बनाने के लिए बुनियादी घटकों को जोड़ती है जो कई ML मॉडल (या कई संस्करण) परोसता है, निगरानी घटक और एक कस्टम आर्किटेक्चर प्रदान करता है।

डॉकटर के साथ काम करते हुए टेंसरफ्लो

आइए मानक Tensorflow Serving सेटिंग्स (CPU अनुकूलन के बिना) के साथ प्रदर्शन का पूर्वानुमान लगाने में विलंबता के मूल मैट्रिक्स पर एक नज़र डालें।

सबसे पहले, TensorFlow Docker हब से नवीनतम छवि डाउनलोड करें:

docker pull tensorflow/serving:latest 

इस अनुच्छेद में, सभी कंटेनर चार कोर, 15 जीबी, उबंटू 16.04 के साथ एक मेजबान पर चलते हैं।

SavedModel को Tensorflow Model निर्यात करें

जब एक मॉडल को टेंसरफ़्लो का उपयोग करके प्रशिक्षित किया जाता है, तो आउटपुट को चर नियंत्रण बिंदु (डिस्क पर फ़ाइलें) के रूप में सहेजा जा सकता है। आउटपुट सीधे मॉडल के नियंत्रण बिंदुओं को पुनर्स्थापित करके या जमे हुए जमे हुए ग्राफ प्रारूप (बाइनरी फ़ाइल) में किया जाता है।

Tensorflow Serving के लिए, इस जमे हुए ग्राफ को SavedModel प्रारूप में निर्यात किया जाना चाहिए। Tensorflow प्रलेखन में SavedModel प्रारूप में प्रशिक्षित मॉडल निर्यात करने के उदाहरण हैं।

Tensorflow प्रयोग, अनुसंधान, या उत्पादन के लिए एक प्रारंभिक बिंदु के रूप में कई आधिकारिक और अनुसंधान मॉडल भी प्रदान करता है।

एक उदाहरण के रूप में, हम 1000 कक्षाओं के एक इमेजनेट डेटासेट को वर्गीकृत करने के लिए गहरे अवशिष्ट तंत्रिका नेटवर्क (ResNet) मॉडल का उपयोग करेंगे। पहले से ResNet-50 v2 मॉडल डाउनलोड करें, विशेष रूप से SavedModel में Channels_last (NHWC) विकल्प : एक नियम के रूप में, यह सीपीयू पर बेहतर काम करता है।

RestNet मॉडल निर्देशिका को निम्न संरचना में कॉपी करें:

 models/ 1/ saved_model.pb variables/ variables.data-00000-of-00001 variables.index 

Tensorflow सर्विंग के लिए संख्यात्मक रूप से क्रमबद्ध निर्देशिका संरचना की अपेक्षा करता है। हमारे मामले में, निर्देशिका 1/ संस्करण 1 मॉडल से मेल खाती है, जिसमें मॉडल वेट (चर) के स्नैपशॉट के साथ saved_model.pb मॉडल की वास्तुकला शामिल है।

बचत और प्रसंस्करण SavedModel

निम्न आदेश Denser कंटेनर में Tensorflow Serving मॉडल सर्वर को प्रारंभ करता है। SavedModel को लोड करने के लिए, आपको अपेक्षित कंटेनर निर्देशिका में मॉडल निर्देशिका को माउंट करना होगा।

 docker run -d -p 9000:8500 \ -v $(pwd)/models:/models/resnet -e MODEL_NAME=resnet \ -t tensorflow/serving:latest 

कंटेनर लॉग की जाँच करने से पता चलता है कि मॉडलरवर जीआरपीसी और एचटीटीपी के समापन बिंदु पर resnet मॉडल के आउटपुट अनुरोधों को संभालने के लिए तैयार है और चल रहा है:

 ... I tensorflow_serving/core/loader_harness.cc:86] Successfully loaded servable version {name: resnet version: 1} I tensorflow_serving/model_servers/server.cc:286] Running gRPC ModelServer at 0.0.0.0:8500 ... I tensorflow_serving/model_servers/server.cc:302] Exporting HTTP/REST API at:localhost:8501 ... 

पूर्वानुमान ग्राहक

Tensorflow Serving प्रोटोकॉल बफ़र्स (protobufs) प्रारूप में एक एपीआई स्कीमा को परिभाषित करता है। पूर्वानुमान एपीआई के लिए जीआरपीसी ग्राहक कार्यान्वयन पायथन पैकेज tensorflow_serving.apis रूप में पैक किए गए हैं। उपयोगिता कार्यों के लिए हमें एक और पायथन पैकेज tensorflow आवश्यकता होगी।

एक साधारण ग्राहक बनाने के लिए निर्भरता स्थापित करें:

 virtualenv .env && source .env/bin/activate && \ pip install numpy grpcio opencv-python tensorflow tensorflow-serving-api 

ResNet-50 v2 मॉडल एक स्वरूपित चैनल_ब्लास्ट (NHWC) डेटा संरचना में फ्लोटिंग पॉइंट ResNet-50 v2 इनपुट की अपेक्षा करता है। इसलिए, इनपुट छवि opencv-python का उपयोग करके पढ़ी जाती है और फ्लोट 32 डेटा प्रकार के रूप में संख्यात्मक सरणी (ऊंचाई × चौड़ाई × चैनल) में लोड होती है। नीचे दी गई स्क्रिप्ट एक भविष्यवाणी क्लाइंट स्टब बनाता है और JPEG डेटा को एक संख्यात्मक सरणी में लोड करता है, इसे gRPC के लिए एक पूर्वानुमान अनुरोध करने के लिए tanor_proto में कनवर्ट करता है:

 #!/usr/bin/env python from __future__ import print_function import argparse import numpy as np import time tt = time.time() import cv2 import tensorflow as tf from grpc.beta import implementations from tensorflow_serving.apis import predict_pb2 from tensorflow_serving.apis import prediction_service_pb2 parser = argparse.ArgumentParser(description='incetion grpc client flags.') parser.add_argument('--host', default='0.0.0.0', help='inception serving host') parser.add_argument('--port', default='9000', help='inception serving port') parser.add_argument('--image', default='', help='path to JPEG image file') FLAGS = parser.parse_args() def main(): # create prediction service client stub channel = implementations.insecure_channel(FLAGS.host, int(FLAGS.port)) stub = prediction_service_pb2.beta_create_PredictionService_stub(channel) # create request request = predict_pb2.PredictRequest() request.model_spec.name = 'resnet' request.model_spec.signature_name = 'serving_default' # read image into numpy array img = cv2.imread(FLAGS.image).astype(np.float32) # convert to tensor proto and make request # shape is in NHWC (num_samples x height x width x channels) format tensor = tf.contrib.util.make_tensor_proto(img, shape=[1]+list(img.shape)) request.inputs['input'].CopyFrom(tensor) resp = stub.Predict(request, 30.0) print('total time: {}s'.format(time.time() - tt)) if __name__ == '__main__': main() 

JPEG इनपुट प्राप्त करने के बाद, एक कार्यशील ग्राहक निम्नलिखित परिणाम प्रस्तुत करेगा:

 python tf_serving_client.py --image=images/pupper.jpg total time: 2.56152906418s 

परिणामी टेंसर में पूर्णांक मान और संकेतों की संभावना के रूप में पूर्वानुमान होता है।

 outputs { key: "classes" value { dtype: DT_INT64 tensor_shape { dim { size: 1 } } int64_val: 238 } } outputs { key: "probabilities" ... 

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

 I external/org_tensorflow/tensorflow/core/platform/cpu_feature_guard.cc:141] Your CPU supports instructions that this TensorFlow binary was not compiled to use: AVX2 FMA 

यह एक CPU प्लेटफ़ॉर्म पर चलने वाले TensorFlow सर्विंग बाइनरी को इंगित करता है जिसके लिए इसे ऑप्टिमाइज़ नहीं किया गया है।

एक अनुकूलित बाइनरी बनाएँ

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


एक विशिष्ट संस्करण की एक टेंसरफ़्लो की क्लोनिंग। हमारे मामले में, यह १.१३ है (इस लेख के प्रकाशन के समय अंतिम):

 USER=$1 TAG=$2 TF_SERVING_VERSION_GIT_BRANCH="r1.13" git clone --branch="$TF_SERVING_VERSION_GIT_BRANCH" https://github.com/tensorflow/serving 

Tensorflow देव छवि का निर्माण करने के लिए बेसल उपकरण का उपयोग करता है। हम इसे CPU निर्देशों के विशिष्ट सेटों के लिए कॉन्फ़िगर करते हैं:

 TF_SERVING_BUILD_OPTIONS="--copt=-mavx --copt=-mavx2 --copt=-mfma --copt=-msse4.1 --copt=-msse4.2" 

यदि पर्याप्त मेमोरी नहीं है, तो ध्वज के साथ निर्माण प्रक्रिया के दौरान मेमोरी की खपत को सीमित करें --local_resources=2048,.5,1.0 । झंडों के बारे में जानकारी के लिए, टेंसोरफ़्लो सर्विंग और डॉकर सहायता, साथ ही साथ बाजेल प्रलेखन देखें ।

मौजूदा एक के आधार पर एक कार्यशील छवि बनाएं:

 #!/bin/bash USER=$1 TAG=$2 TF_SERVING_VERSION_GIT_BRANCH="r1.13" git clone --branch="${TF_SERVING_VERSION_GIT_BRANCH}" https://github.com/tensorflow/serving TF_SERVING_BUILD_OPTIONS="--copt=-mavx --copt=-mavx2 --copt=-mfma --copt=-msse4.1 --copt=-msse4.2" cd serving && \ docker build --pull -t $USER/tensorflow-serving-devel:$TAG \ --build-arg TF_SERVING_VERSION_GIT_BRANCH="${TF_SERVING_VERSION_GIT_BRANCH}" \ --build-arg TF_SERVING_BUILD_OPTIONS="${TF_SERVING_BUILD_OPTIONS}" \ -f tensorflow_serving/tools/docker/Dockerfile.devel . cd serving && \ docker build -t $USER/tensorflow-serving:$TAG \ --build-arg TF_SERVING_BUILD_IMAGE=$USER/tensorflow-serving-devel:$TAG \ -f tensorflow_serving/tools/docker/Dockerfile . 

ModelServer को समसामयिक समर्थन करने के लिए TensorFlow झंडे का उपयोग करके कॉन्फ़िगर किया गया है। निम्नलिखित विकल्प समानांतर संचालन के लिए दो थ्रेड पूल को कॉन्फ़िगर करते हैं:

 intra_op_parallelism_threads 

• एक ऑपरेशन के समानांतर निष्पादन के लिए थ्रेड्स की अधिकतम संख्या को नियंत्रित करता है;
  
• उन कार्यों को समानांतर करने के लिए उपयोग किया जाता है जिनके उप-संचालन होते हैं जो प्रकृति में स्वतंत्र होते हैं।

 inter_op_parallelism_threads 

• स्वतंत्र संचालन के समानांतर निष्पादन के लिए थ्रेड्स की अधिकतम संख्या को नियंत्रित करता है;
  
• Tensorflow ग्राफ़ संचालन, जो एक दूसरे से स्वतंत्र हैं और इसलिए, विभिन्न थ्रेड्स में प्रदर्शन किया जा सकता है।

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

फिर सर्विसिंग कंटेनर को पिछले एक की तरह से चलाएं, इस बार स्रोतों से संकलित डॉकटर छवि के साथ और एक विशिष्ट प्रोसेसर के लिए टेन्सरफ़्लो ऑप्टिमाइज़ेशन फ़्लैग के साथ:

 docker run -d -p 9000:8500 \ -v $(pwd)/models:/models/resnet -e MODEL_NAME=resnet \ -t $USER/tensorflow-serving:$TAG \ --tensorflow_intra_op_parallelism=4 \ --tensorflow_inter_op_parallelism=4 

कंटेनर लॉग को अब एक अपरिभाषित सीपीयू के बारे में चेतावनी नहीं दिखानी चाहिए। एक ही पूर्वानुमान अनुरोध पर कोड को बदलने के बिना, देरी लगभग 35.8% कम हो जाती है:

 python tf_serving_client.py --image=images/pupper.jpg total time: 1.64234706879s 

ग्राहक पूर्वानुमान में गति बढ़ाएं

क्या अब भी तेजी संभव है? हमने अपने सीपीयू के लिए सर्वर साइड को अनुकूलित किया है, लेकिन 1 सेकंड से अधिक की देरी अभी भी बहुत बड़ी लगती है।

ऐसा हुआ कि tensorflow_serving और tensorflow tensorflow_serving लोड करना देरी में महत्वपूर्ण योगदान देता है। प्रत्येक अनावश्यक कॉल tf.contrib.util.make_tensor_proto एक विभाजन दूसरा भी जोड़ता है।

आप पूछ सकते हैं: "क्या हमें TensorFlow पायथन पैकेजों की आवश्यकता नहीं है जो वास्तव में Tensorflow सर्वर के लिए पूर्वानुमान अनुरोध करता है?" वास्तव में, tensorflow_serving और tensorflow पैकेज की कोई वास्तविक आवश्यकता नहीं है।

जैसा कि पहले उल्लेख किया गया है, टेन्सरफ़्लो भविष्यवाणी एपीआई को प्रोटो-बफ़र के रूप में परिभाषित किया गया है। इसलिए, दो बाहरी निर्भरताएँ इसी tensorflow और tensorflow_serving साथ प्रतिस्थापित की जा सकती हैं - और फिर आपको क्लाइंट पर संपूर्ण (भारी) टेन्सफ़्लो लाइब्रेरी को खींचने की आवश्यकता नहीं है।

सबसे पहले, tensorflow और tensorflow_serving से छुटकारा tensorflow और grpcio-tools पैकेज जोड़ें।

 pip uninstall tensorflow tensorflow-serving-api && \ pip install grpcio-tools==1.0.0 

tensorflow/tensorflow और tensorflow/serving रिपॉजिटरी को क्लोन करें और tensorflow/serving लिए निम्न प्रोटोबॉफ़ फ़ाइलों को कॉपी करें:

 tensorflow/serving/ tensorflow_serving/apis/model.proto tensorflow_serving/apis/predict.proto tensorflow_serving/apis/prediction_service.proto tensorflow/tensorflow/ tensorflow/core/framework/resource_handle.proto tensorflow/core/framework/tensor_shape.proto tensorflow/core/framework/tensor.proto tensorflow/core/framework/types.proto 

संरक्षित किए गए मूल रास्तों के साथ इन protos/ फ़ाइलों को protos/ निर्देशिका में कॉपी करें:

 protos/ tensorflow_serving/ apis/ *.proto tensorflow/ core/ framework/ *.proto 

सादगी के लिए, केवल भविष्यवाणी RPC को लागू करने के लिए prediction_service.proto को सरल बनाया जा सकता है ताकि सेवा में निर्दिष्ट अन्य RPC की नेस्टेड निर्भरता को डाउनलोड न किया जा सके। यहाँ एक सरलीकृत prediction_service. का उदाहरण दिया गया है।

Grpcio.tools.protoc का उपयोग करके पायथन जीआरपीसी कार्यान्वयन बनाएं:

 PROTOC_OUT=protos/ PROTOS=$(find . | grep "\.proto$") for p in $PROTOS; do python -m grpc.tools.protoc -I . --python_out=$PROTOC_OUT --grpc_python_out=$PROTOC_OUT $p done 

अब पूरे tensorflow_serving को हटाया जा सकता है:

 from tensorflow_serving.apis import predict_pb2 from tensorflow_serving.apis import prediction_service_pb2 

... और protos/tensorflow_serving/apis से उत्पन्न protos/tensorflow_serving/apis साथ बदलें:

 from protos.tensorflow_serving.apis import predict_pb2 from protos.tensorflow_serving.apis import prediction_service_pb2 

Tensorflow लाइब्रेरी को हेल्पर फंक्शन make_tensor_proto का उपयोग करने के लिए आयात किया जाता है, जिसे TensorProto ऑब्जेक्ट के रूप में एक अजगर / संख्यात्मक ऑब्जेक्ट को लपेटने की आवश्यकता होती है।

इस प्रकार, हम निम्नलिखित निर्भरता और कोड के टुकड़े को बदल सकते हैं:

 import tensorflow as tf ... tensor = tf.contrib.util.make_tensor_proto(features) request.inputs['inputs'].CopyFrom(tensor) 

प्रोटोबफ़र्स आयात करें और TensorProto ऑब्जेक्ट का निर्माण करें:

 from protos.tensorflow.core.framework import tensor_pb2 from protos.tensorflow.core.framework import tensor_shape_pb2 from protos.tensorflow.core.framework import types_pb2 ... # ensure NHWC shape and build tensor proto tensor_shape = [1]+list(img.shape) dims = [tensor_shape_pb2.TensorShapeProto.Dim(size=dim) for dim in tensor_shape] tensor_shape = tensor_shape_pb2.TensorShapeProto(dim=dims) tensor = tensor_pb2.TensorProto( dtype=types_pb2.DT_FLOAT, tensor_shape=tensor_shape, float_val=list(img.reshape(-1))) request.inputs['inputs'].CopyFrom(tensor) 

पूर्ण पायथन लिपि यहाँ है । एक अद्यतन स्टार्टर क्लाइंट चलाएं जो अनुकूलित Tensorflow सर्विंग के लिए एक पूर्वानुमान अनुरोध करता है:

 python tf_inception_grpc_client.py --image=images/pupper.jpg total time: 0.58314920859s 

निम्न आरेख मानक के मुकाबले 10 से अधिक रन के टेनसफ़्लो सेवा के अनुकूलित संस्करण में पूर्वानुमान निष्पादन समय को दर्शाता है:



औसत विलंब लगभग 3.38 गुना कम हुआ।

बैंडविड्थ अनुकूलन

बड़ी मात्रा में डेटा को संभालने के लिए टेंसरफ़्लो सर्विंग को कॉन्फ़िगर किया जा सकता है। बैंडविड्थ अनुकूलन आमतौर पर "स्टैंड-अलोन" बैच प्रसंस्करण के लिए किया जाता है, जहां तंग विलंबता सीमाएं एक सख्त आवश्यकता नहीं हैं।

सर्वर साइड बैच प्रसंस्करण

जैसा कि प्रलेखन में कहा गया है, सर्वर-साइड बैच प्रोसेसिंग मूल रूप से टेन्सरफ़्लो सर्विंग में समर्थित है।

लेटेंसी और थ्रूपुट के बीच के ट्रेड-ऑफ का निर्धारण बैच प्रोसेसिंग मापदंडों द्वारा किया जाता है। वे आपको अधिकतम थ्रूपुट प्राप्त करने की अनुमति देते हैं जो हार्डवेयर त्वरक सक्षम हैं।

पैकेजिंग को सक्षम करने के लिए, --enable_batching और --batching_parameters_file सेट करें। पैरामीटर SessionBundleConfig के अनुसार सेट किए गए हैं। सीपीयू पर सिस्टम के लिए, उपलब्ध कोर की संख्या के लिए num_batch_threads सेट करें। GPU के लिए, यहां उपयुक्त पैरामीटर देखें।

सर्वर साइड पर पूरे पैकेज को भरने के बाद, जारी करने के अनुरोधों को एक बड़े अनुरोध (टेंसर) में जोड़ दिया जाता है, और एक संयुक्त अनुरोध के साथ टेन्सरफ़्लो सत्र में भेजा जाता है। इस स्थिति में, CPU / GPU समानता वास्तव में शामिल है।

Tensorflow बैच प्रसंस्करण के लिए कुछ सामान्य उपयोग:

• सर्वर-साइड पैकेट को पॉप्युलेट करने के लिए एसिंक्रोनस क्लाइंट अनुरोधों का उपयोग करना
  
• मॉडल ग्राफ के घटकों को सीपीयू / जीपीयू में स्थानांतरित करके तेज़ बैच प्रसंस्करण
  
• एकल सर्वर से कई मॉडलों से अनुरोध करना
  
• बड़ी संख्या में अनुरोधों के "ऑफ़लाइन" प्रसंस्करण के लिए बैच प्रसंस्करण की अत्यधिक अनुशंसा की जाती है

क्लाइंट साइड बैच प्रसंस्करण

क्लाइंट-साइड बैच प्रसंस्करण समूह कई आवक अनुरोधों को एक में रखता है।

चूंकि रेसनेट मॉडल NHWC प्रारूप में इनपुट का इंतजार कर रहा है (पहला आयाम इनपुट की संख्या है), हम कई इनपुट छवियों को एक आरपीसी अनुरोध में जोड़ सकते हैं:

 ... batch = [] for jpeg in os.listdir(FLAGS.images_path): path = os.path.join(FLAGS.images_path, jpeg) img = cv2.imread(path).astype(np.float32) batch.append(img) ... batch_np = np.array(batch).astype(np.float32) dims = [tensor_shape_pb2.TensorShapeProto.Dim(size=dim) for dim in batch_np.shape] t_shape = tensor_shape_pb2.TensorShapeProto(dim=dims) tensor = tensor_pb2.TensorProto( dtype=types_pb2.DT_FLOAT, tensor_shape=t_shape, float_val=list(batched_np.reshape(-1))) request.inputs['inputs'].CopyFrom(tensor) 

एन छवियों के एक पैकेट के लिए, प्रतिक्रिया में आउटपुट टेंसर में समान संख्या में इनपुट के लिए भविष्यवाणी परिणाम होंगे। हमारे मामले में, एन = 2:

 outputs { key: "classes" value { dtype: DT_INT64 tensor_shape { dim { size: 2 } } int64_val: 238 int64_val: 121 } } ... 

हार्डवेयर त्वरण

GPU के बारे में कुछ शब्द।

सीखने की प्रक्रिया स्वाभाविक रूप से GPU पर समानांतरीकरण का उपयोग करती है, क्योंकि गहन तंत्रिका नेटवर्क के निर्माण के लिए इष्टतम समाधान प्राप्त करने के लिए बड़े पैमाने पर कम्प्यूटेशंस की आवश्यकता होती है।

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

GPU पर जाने से पहले, सबसे बड़ी लाभ (कम विलंबता, उच्च थ्रूपुट) के लिए लागत (मौद्रिक, परिचालन, तकनीकी) के सावधानीपूर्वक विश्लेषण के साथ व्यावसायिक आवश्यकताओं पर विचार करें।