वैल्यू का अनुमान लगाने के लिए एक iOS ऐप्लिकेशन बनाएं

वैल्यू का अनुमान लगाने के लिए एक iOS ऐप्लिकेशन बनाएं

इस कोडलैब (कोड बनाना सीखने के लिए ट्यूटोरियल) के बारे में जानकारी

subjectपिछली बार अप्रैल 8, 2022 को अपडेट किया गया
account_circleWei Wei ने लिखा

1. शुरू करने से पहले

इस कोडलैब में आप REST और gRPC के साथ TensorFlow सर्विंग का इस्तेमाल करके, iOS ऐप्लिकेशन से रिग्रेशन अनुमान चलाने का तरीका जान सकते हैं.

ज़रूरी बातें

  • Swift के साथ iOS डेवलपमेंट की बुनियादी जानकारी
  • TensorFlow का इस्तेमाल करके, मशीन लर्निंग के बारे में बुनियादी जानकारी, जैसे कि ट्रेनिंग और डिप्लॉयमेंट
  • Colaboratory की बुनियादी जानकारी
  • टर्मिनल, Python, और डॉकर की बुनियादी जानकारी

आप इन चीज़ों के बारे में जानेंगे

  • TensorFlow की मदद से, रिग्रेशन मॉडल को ट्रेनिंग देने का तरीका.
  • आसान iOS ऐप्लिकेशन बनाने का तरीका. साथ ही, TensorFlow सर्विंग (REST और gRPC) की मदद से, प्रशिक्षित मॉडल की मदद से अनुमान लगाएं.
  • यूज़र इंटरफ़ेस (यूआई) में नतीजे को दिखाने का तरीका.

आपको इनकी ज़रूरत होगी

2. सेट अप करें

इस कोडलैब के लिए कोड डाउनलोड करने के लिए:

  1. इस कोडलैब के लिए, GitHub की रिपॉज़िटरी पर जाएं.
  2. इस कोडलैब के सभी कोड डाउनलोड करने के लिए, कोड > ज़िप डाउनलोड करें पर क्लिक करें.

a72f2bb4caa9a96.png

  1. codelabs रूट फ़ोल्डर को अनलॉक करने के लिए, डाउनलोड किए गए zip फ़ाइल को अनज़िप करें. इसमें आपको सभी ज़रूरी संसाधन मिलेंगे.

इस कोडलैब के लिए, आपको रिपॉज़िटरी में सिर्फ़ TFServing/RegressioniOS सबडायरेक्ट्री की फ़ाइलों की ज़रूरत होती है, जिसमें दो फ़ोल्डर होते हैं:

  • starter फ़ोल्डर में वह स्टार्टर कोड शामिल है जिसे आपने इस कोडलैब के लिए बनाया है.
  • finished फ़ोल्डर में, तैयार हो चुके सैंपल ऐप्लिकेशन का पूरा कोड है.

3. प्रोजेक्ट के लिए डिपेंडेंसी डाउनलोड करना

ज़रूरी पॉड डाउनलोड करें

  • starter/iOS फ़ोल्डर में, यह चलाएं:
pod install

कोकोपॉड, सभी ज़रूरी लाइब्रेरी को इंस्टॉल करेंगे और एक नई regression.xcworkspace फ़ाइल जनरेट करेंगे.

4. स्टार्टर ऐप्लिकेशन चलाएं

  • Xcode खोलने के लिए, regression.xcworkspace फ़ाइल पर दो बार क्लिक करें.

ऐप्लिकेशन चलाएं और उसके बारे में ज़्यादा जानें

  1. डिवाइस टारगेट को किसी iPhone में बदलें, जैसे कि iPhone 13.

a57198a4f21f970.png

  1. cac15c5638260ed.png 'चलाएं' पर क्लिक करें. इसके बाद, प्रोजेक्ट कंपाइल करने और सिम्युलेटर में स्टार्टर ऐप्लिकेशन शुरू करने के लिए, Xcode का इंतज़ार करें.

यूज़र इंटरफ़ेस (यूआई) बहुत आसान है. यह एक टेक्स्ट बॉक्स है, जिसमें आप एक नंबर लिख सकते हैं. इसे REST या gRPC की मदद से, TensorFlow सर्विंग बैकएंड में भेजा जाता है. बैकएंड, इनपुट वैल्यू पर रिग्रेशन करता है और क्लाइंट ऐप्लिकेशन को अनुमानित वैल्यू दिखाता है. इससे, यूज़र इंटरफ़ेस (यूआई) में नतीजे फिर से दिखने लगते हैं.

d2976072474ce0b1.png

अगर आप कोई नंबर डालते हैं और अनुमानित पर क्लिक करते हैं, तो कुछ भी नहीं होता. ऐसा इसलिए होता है, क्योंकि ऐप्लिकेशन अभी बैकएंड में बातचीत नहीं कर सकता.

5. TensorFlow की मदद से, रिग्रेशन मॉडल को बेहतर बनाएं

रिग्रेशन: आम तौर पर किए जाने वाले एमएल टास्क में से एक है. इसका लक्ष्य, इनपुट के आधार पर, लगातार एक वॉल्यूम का अनुमान लगाना है. उदाहरण के लिए, आज के मौसम के हिसाब से, कल के सबसे ज़्यादा तापमान का अनुमान लगाएं.

रिग्रेशन मॉडल को ट्रेनिंग दें

  1. अपने ब्राउज़र में यह लिंक खोलें.

Colab, Python नोटबुक को लोड करता है.

  1. Python नोटबुक में, TensorFlow और NumPy लाइब्रेरी इंपोर्ट करें. इसके बाद, इनपुट के तौर पर xs और लेबल के तौर पर ys के साथ छह पेयर ट्रेनिंग डेटा बनाएं.

अगर आप इन डेटा पॉइंट को किसी ग्राफ़ पर दिखाते हैं, तो वे असल में सीधी रेखा में होते हैं, क्योंकि वे y = 2x -1 इक्वेशन से जनरेट होती हैं.

56d05252cfc9df9d.png

  1. Keras API का इस्तेमाल करके, y इनपुट के आधार पर y वैल्यू का अनुमान लगाने के लिए, दो लेयर वाला एक आसान न्यूरल नेटवर्क बनाएं. इसके बाद, मॉडल को कंपाइल और फ़िट करें.
xs = np.array([-1.0,  0.0, 1.0, 2.0, 3.0, 4.0], dtype=float)
ys = np.array([-3.0, -1.0, 1.0, 3.0, 5.0, 7.0], dtype=float)

model = tf.keras.Sequential([
   tf.keras.layers.Dense(units=10, input_shape=[1]),
   tf.keras.layers.Dense(units=1),
   ])

model.compile(optimizer='sgd',
             loss='mean_squared_error')

history = model.fit(xs, ys, epochs=500, verbose=0)

print("Finished training the model")

print(model.predict([10.0]))

मॉडल को ट्रेनिंग देने में कुछ सेकंड लगते हैं. साथ ही, आप 10 इनपुट के लिए अनुमानित वैल्यू 18.999996 देख सकते हैं, क्योंकि बुनियादी सच्चाई यह है कि 2 * 10 -1 = 19 है.

  1. मॉडल एक्सपोर्ट करें:
model_dir = './regression/'
version = 123
export_path = os.path.join(model_dir, str(version))
model.save(export_path, save_format="tf")
print('\nexport_path = {}'.format(export_path))
!ls -l {export_path}
  1. एक्सपोर्ट किए गए सेव किए गए मॉडल को, एक regression.zip फ़ाइल में ज़िप करें:
!zip -r regression.zip ./regression
  1. नोटबुक को चलाने के लिए, नेविगेशन मेन्यू में रनटाइम &सभी चलाएं पर क्लिक करें और फिर रन के पूरा होने का इंतज़ार करें.
  2. c55600d42359f901.png फ़ाइलें पर क्लिक करें और फिर regression.zip फ़ाइल डाउनलोड करें.

bceda15d86571583.png

6. TensorFlow सर्विंग के साथ रिग्रेशन मॉडल को डिप्लॉय करना

  • TensorFlow सर्विंग के साथ मॉडल को लागू करने के लिए, डाउनलोड की गई regression.zip फ़ाइल को कंप्रेस करें. ऐसा करने पर, कंप्रेस करने के टूल का इस्तेमाल किया जाता है, जैसे कि 7-ZIP.

फ़ोल्डर का स्ट्रक्चर इस इमेज जैसा दिखना चाहिए:

7faeb4f03af39646.png

आप regression फ़ोल्डर को SavedModel फ़ोल्डर के तौर पर देख सकते हैं. 123, वर्शन नंबर का उदाहरण है. अगर आप चाहें, तो दूसरा नंबर चुन सकते हैं.

TensorFlow सर्विंग शुरू करें

  • अपने टर्मिनल में, TensorFlow सेवा को डॉक करने वाले टूल से शुरू करें. हालांकि, अपने कंप्यूटर पर PATH/TO/SAVEDMODEL प्लेसहोल्डर की जगह regression फ़ोल्डर का इस्तेमाल करें.
docker pull tensorflow/serving

docker run -it --rm -p 8500:8500 -p 8501:8501 -v "PATH/TO/SAVEDMODEL:/models/regression" -e MODEL_NAME=regression tensorflow/serving

डॉकर सबसे पहले TensorFlow सर्विंग इमेज को अपने-आप डाउनलोड कर लेता है. इसमें एक मिनट लगता है. इसके बाद, TensorFlow सर्विंग शुरू हो जानी चाहिए. लॉग इस कोड स्निपेट जैसा दिखना चाहिए:

2022-02-25 06:01:12.513231: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:206] Restoring SavedModel bundle.
2022-02-25 06:01:12.585012: I external/org_tensorflow/tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 3000000000 Hz
2022-02-25 06:01:13.395083: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:190] Running initialization op on SavedModel bundle at path: /models/ssd_mobilenet_v2_2/123
2022-02-25 06:01:13.837562: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:277] SavedModel load for tags { serve }; Status: success: OK. Took 1928700 microseconds.
2022-02-25 06:01:13.877848: I tensorflow_serving/servables/tensorflow/saved_model_warmup_util.cc:59] No warmup data file found at /models/ssd_mobilenet_v2_2/123/assets.extra/tf_serving_warmup_requests
2022-02-25 06:01:13.929844: I tensorflow_serving/core/loader_harness.cc:87] Successfully loaded servable version {name: regression version: 123}
2022-02-25 06:01:13.985848: I tensorflow_serving/model_servers/server_core.cc:486] Finished adding/updating models
2022-02-25 06:01:13.985987: I tensorflow_serving/model_servers/server.cc:367] Profiler service is enabled
2022-02-25 06:01:13.988994: I tensorflow_serving/model_servers/server.cc:393] Running gRPC ModelServer at 0.0.0.0:8500 ...
[warn] getaddrinfo: address family for nodename not supported
2022-02-25 06:01:14.033872: I tensorflow_serving/model_servers/server.cc:414] Exporting HTTP/REST API at:localhost:8501 ...
[evhttp_server.cc : 245] NET_LOG: Entering the event loop ...

7. REST के ज़रिए iOS ऐप्लिकेशन को TensorFlow सेवा से कनेक्ट करना

अब आपका बैकएंड तैयार है. इसलिए, आप अनुमान लगाने के लिए, TensorFlow सर्विंग को क्लाइंट के अनुरोध भेज सकते हैं. TensorFlow सर्विंग को दो तरीकों से अनुरोध भेजे जा सकते हैं:

  • आरएसटी
  • gRPC

REST से अनुरोध भेजें और जवाब पाएं

तीन आसान चरण हैं:

  1. REST अनुरोध बनाएं.
  2. TensorFlow सर्विंग को REST का अनुरोध भेजें.
  3. REST के जवाब से अनुमानित नतीजे निकालें और यूज़र इंटरफ़ेस (यूआई) को रेंडर करें.

आप iOS/regression/ViewController.swift फ़ाइल में इन चरणों को पूरा करते हैं.

REST अनुरोध बनाएं

  1. फ़िलहाल, doInference() फ़ंक्शन'TenorFlow से सर्व करने के लिए REST अनुरोध नहीं भेजता. REST का अनुरोध करने के लिए, आपको इस REST ब्रांच को लागू करना होगा:
if (connectionMode[picker.selectedRow(inComponent: 0)] == "REST") {
    print("Using REST")
    // TODO: Add code to send a REST request to TensorFlow Serving.
    
}

TensorFlow सर्विंग एक POST अनुरोध की उम्मीद करता है, जिसमें एक मान होता है. इसलिए, आपको इनपुट वैल्यू को JSON में एम्बेड करना होगा. यह अनुरोध का पेलोड है.

  1. इस कोड को REST शाखा में जोड़ें:
//Create the REST request.
let json: [String: Any] = ["signature_name" : "serving_default", "instances" : [[value]]]

let jsonData = try? JSONSerialization.data(withJSONObject: json)

let url = URL(string: "http://localhost:8501/v1/models/regression:predict")!
var request = URLRequest(url: url)
request.httpMethod = "POST"

// Insert JSON data into the request.
request.httpBody = jsonData

TensorFlow सर्विंग के लिए REST अनुरोध भेजें

  • REST की ब्रांच में कोड के तुरंत बाद यह कोड जोड़ें:
// Send the REST request.
let task = URLSession.shared.dataTask(with: request) { data, response, error in
    guard let data = data, error == nil else {
        print(error?.localizedDescription ?? "No data")
        return
    }
    
    // TODO: Add code to process the response.
}

task.resume()

TensorFlow सर्विंग से मिलने वाले REST के जवाब को प्रोसेस करें

  • इस टिप्पणी को TODO: Add code to process the response. टिप्पणी के तुरंत बाद पिछले कोड स्निपेट में जोड़ें:
// Process the REST response.
let results: RESTResults = try! JSONDecoder().decode(RESTResults.self, from: data)
DispatchQueue.main.async{
    self.txtOutput.text = String(results.predictions[0][0])
}

अब पोस्टप्रोसेसिंग फ़ंक्शन, जवाब से अनुमानित वैल्यू निकालता है और नतीजे को यूज़र इंटरफ़ेस (यूआई) में दिखाता है.

इसे चलाएं

  1. cac15c5638260ed.png ‘चलाएं' पर क्लिक करें. इसके बाद, सिम्युलेटर में ऐप्लिकेशन के लॉन्च होने तक Xcode का इंतज़ार करें.
  2. टेक्स्ट बॉक्स में कोई संख्या डालें. इसके बाद, अनुमानित पर क्लिक करें.

अब आपको यूज़र इंटरफ़ेस (यूआई) में अनुमानित वैल्यू दिखती है.

df9bcb9aa21bb30e.png

8. gRPC की मदद से, iOS ऐप्लिकेशन को TensorFlow सर्विंग से कनेक्ट करें

REST के अलावा, TensorFlow सर्व करने की सुविधा gRPC पर भी काम करती है.

b6f4499c2c850b0e.png

gRPC एक आधुनिक, ओपन सोर्स, हाई-परफ़ॉर्मेंस रिमोट प्रोसेस कॉल (आरपीसी) फ़्रेमवर्क है, जो किसी भी एनवायरमेंट में चल सकता है. यह डेटा केंद्रों में, लोड बैलेंसिंग, ट्रेसिंग, स्वास्थ्य जांच, और पुष्टि करने की सुविधा के साथ बेहतर तरीके से सेवाओं को कनेक्ट कर सकती है. यह देखा गया है कि REST की तुलना में gRPC, बेहतर परफ़ॉर्म करता है.

gRPC से अनुरोध भेजें और जवाब पाएं

चार आसान चरण हैं:

  1. ज़रूरी नहीं: gRPC क्लाइंट स्टब कोड जनरेट करें.
  2. जीआरपीसी अनुरोध बनाएं.
  3. TensorFlow सर्विंग के लिए जीआरपीसी अनुरोध भेजें.
  4. gRPC रिस्पॉन्स से अनुमानित नतीजा निकालें और यूज़र इंटरफ़ेस (यूआई) को रेंडर करें.

आप iOS/regression/ViewController.swift फ़ाइल में इन चरणों को पूरा करते हैं.

ज़रूरी नहीं: gRPC क्लाइंट स्टब कोड जनरेट करें

TensorFlow सर्विंग के साथ जीआरपीसी का इस्तेमाल करने के लिए, आपको जीआरपीसी वर्कफ़्लो को फ़ॉलो करना होगा. ज़्यादा जानकारी के लिए, gRPC दस्तावेज़ देखें.

a9d0e5cb543467b4.png

TensorFlow सर्विंग और TensorFlow आपके लिए .proto फ़ाइलें तय करते हैं. TensorFlow और TensorFlow 2.8 वर्शन के लिए, ये .proto फ़ाइलें ज़रूरी हैं:

tensorflow/core/example/example.proto
tensorflow/core/example/feature.proto
tensorflow/core/protobuf/struct.proto
tensorflow/core/protobuf/saved_object_graph.proto
tensorflow/core/protobuf/saver.proto
tensorflow/core/protobuf/trackable_object_graph.proto
tensorflow/core/protobuf/meta_graph.proto
tensorflow/core/framework/node_def.proto
tensorflow/core/framework/attr_value.proto
tensorflow/core/framework/function.proto
tensorflow/core/framework/types.proto
tensorflow/core/framework/tensor_shape.proto
tensorflow/core/framework/full_type.proto
tensorflow/core/framework/versions.proto
tensorflow/core/framework/op_def.proto
tensorflow/core/framework/graph.proto
tensorflow/core/framework/tensor.proto
tensorflow/core/framework/resource_handle.proto
tensorflow/core/framework/variable.proto

tensorflow_serving/apis/inference.proto
tensorflow_serving/apis/classification.proto
tensorflow_serving/apis/predict.proto
tensorflow_serving/apis/regression.proto
tensorflow_serving/apis/get_model_metadata.proto
tensorflow_serving/apis/input.proto
tensorflow_serving/apis/prediction_service.proto
tensorflow_serving/apis/model.proto

जीआरपीसी क्लाइंट स्टब कोड जनरेट करने के लिए:

  1. अपने टर्मिनल में, starter/src/proto/ फ़ोल्डर पर जाएं और फिर स्टब जनरेट करें:
bash generate_grpc_stub_swift.sh

starter/src/proto/generated/import फ़ोल्डर में कई .swift फ़ाइलें जनरेट होती हैं.

  1. अगर उन्हें आपके प्रोजेक्ट में अभी तक कॉपी नहीं किया गया है, तो जनरेट की गई सभी .swift फ़ाइलों को Xcode में अपने प्रोजेक्ट में खींचें और छोड़ें.

9e65705cf6be7aac.png

जीआरपीसी अनुरोध बनाएं

REST अनुरोध की तरह ही, gRPC ब्रांच में gRPC अनुरोध बनाया जाता है.

if (connectionMode[picker.selectedRow(inComponent: 0)] == "REST") {
    
}
else {
    print("Using gRPC")
    // TODO: add code to send a gRPC request to TF Serving
    
}
  • जीआरपीसी अनुरोध बनाने के लिए, जीआरपीसी शाखा में यह कोड जोड़ें:
//Create the gRPC request.
let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
let channel = ClientConnection.insecure(group: group).connect(host: "localhost", port: 8500)
let stub = Tensorflow_Serving_PredictionServiceClient(channel: channel)

var modelSpec = Tensorflow_Serving_ModelSpec()
modelSpec.name = "regression"
modelSpec.signatureName = "serving_default"

// Prepare the input tensor.
var batchDim = Tensorflow_TensorShapeProto.Dim()
batchDim.size = 1
var inputDim = Tensorflow_TensorShapeProto.Dim()
inputDim.size = 1
var inputTensorShape = Tensorflow_TensorShapeProto()
inputTensorShape.dim = [batchDim, inputDim]
var inputTensor = Tensorflow_TensorProto()
inputTensor.dtype = Tensorflow_DataType.dtFloat
inputTensor.tensorShape = inputTensorShape
inputTensor.floatVal = [Float(value)]

var request = Tensorflow_Serving_PredictRequest()
request.modelSpec = modelSpec
request.inputs = ["dense_input" : inputTensor]

let callOptions = CallOptions(timeLimit: .timeout(.seconds(15)))

TensorFlow सर्व करने के लिए, जीआरपीसी का अनुरोध भेजें

  • पिछले कोड स्निपेट में कोड के तुरंत बाद, इस कोड को gRPC ब्रांच में जोड़ें:
// Send the gRPC request.
let call = stub.predict(request, callOptions: callOptions)

TensorFlow सर्विंग से जीआरपीसी जवाब को प्रोसेस करें

  • पिछले कोड स्निपेट में कोड के तुरंत बाद यह कोड जोड़ें:
// Process the response.
call.response.whenSuccess { response in
    let result = response.outputs["dense_1"]?.floatVal[0]
    DispatchQueue.main.async{
        self.txtOutput.text = String(describing: result!)
    }
}
call.response.whenFailure { error in
    print("Call failed with error\n\(error)")
}

अब पोस्टप्रोसेसिंग फ़ंक्शन, जवाब से अनुमानित वैल्यू निकालता है और नतीजे को यूज़र इंटरफ़ेस (यूआई) में दिखाता है.

इसे चलाएं

  1. नेविगेशन मेन्यू में जाकर, cac15c5638260ed.png ‘चलाएं' पर क्लिक करें. इसके बाद, सिम्युलेटर में ऐप्लिकेशन के लॉन्च होने तक Xcode का इंतज़ार करें.
  2. टेक्स्ट बॉक्स में कोई संख्या डालें. इसके बाद, अनुमानित पर क्लिक करें.

अब आपको यूज़र इंटरफ़ेस (यूआई) में अनुमानित वैल्यू दिखती है.

9. बधाई हो

आपने अपने ऐप्लिकेशन में रिग्रेशन क्षमताओं को जोड़ने के लिए, TensorFlow सर्विंग का इस्तेमाल किया!

ज़्यादा जानें

bug_report गलती की शिकायत करें