بارگذاری یک مدل TensorFlow از پیش آموزش دیده در سرویس TensorFlow

معرفی

شما بخشی از پروژه ای هستید که از یادگیری عمیق برای شناسایی آنچه در تصاویر است استفاده می کند – مانند ماشین ها، اردک ها، کوه ها، آسمان، درختان و غیره.

در این پروژه، دو چیز مهم است – اولین مورد، این است که مدل یادگیری عمیق به سرعت و با کارایی آموزش می بیند (زیرا مدل در دستگاهی که قدرت محاسباتی زیادی ندارد مستقر می شود):

تیم شما تصمیم به استفاده گرفته است EfficientNetsبه طور خاص، خانواده V2، چون قوی هستند، سریع تمرین می کنند و دقت بالایی دارند.

و مورد دوم این است که مدل باید از طریق یک پیوند قابل دسترسی باشد، بنابراین می توان پیش بینی ها را در وب انجام داد:

با توجه به نکته دوم، شما می خواهید بتوانید مدل را در دسترس افراد دیگر قرار دهید، به گونه ای که آنها بتوانند داده های خود را از طریق یک درخواست REST API ارسال کنند و پیش بینی های مدل را به عنوان پاسخ دریافت کنند. برای انجام این کار، شما نیاز به استقرار یا ارائه یک مدل دارید، که می‌تواند به روش‌های بی‌شماری انجام شود – هرچند که ما نگاهی به آن خواهیم داشت سرویس تنسورفلو (سرویس TF).

تا اینجا خوب، دو نیاز اول پروژه توسط EfficientNetV2 و TF Serving پوشش داده شده است! در این راهنما، ما با یک طبقه‌بندی‌کننده تصویر کلی مدل از پیش آموزش‌دیده شروع می‌کنیم و آن را با استفاده از Docker در سرویس TensorFlow اجرا می‌کنیم.

سرویس TensorFlow

سرویس TensorFlow، خوب، یک سیستم خدمت رسانی برای مدل های یادگیری ماشین است. این به طور خاص برای محیط های تولید طراحی شده است و به پر کردن شکاف بین دانشمندان داده و مهندسین نرم افزار تولید محور کمک می کند.

می‌توانید آن را از منبع نصب کنید، که امکان سفارشی‌سازی (برای موارد استفاده خاص) را فراهم می‌کند یا با استفاده از آن، ادغام آن با هر سیستم عاملی را اولویت‌بندی کنید. کانتینرهای داکر. از آنجایی که نیازی به سفارشی سازی نیست و ما در حال آماده سازی مدل برای تولید هستیم، کانتینرهای Docker یک انتخاب عالی برای ما هستند.

Docker یک لایه بین آنچه در حال استقرار یا ارائه می شود و سیستم عامل ایجاد می کند، بنابراین در صورت ایجاد هرگونه تغییر پروژه در آینده یا توسعه به سایر سیستم عامل ها، مقیاس بندی و تطبیق آن آسان تر است.

این زمینه کلی پروژه است. اکنون، اجازه دهید شروع به نصب کتابخانه های مدل لازم، راه اندازی آن کنیم container و آموزش روش خدمت به مدل!

وارد کردن تنسورفلو

اگر قبلاً این کار را نکرده اید، بیایید TensorFlow را نصب کنیم. در یک محیط مبتنی بر Conda، می توانید بدوید conda install:

$ conda install tensorflow

در غیر این صورت، pip آن را ساده می کند:

$ pip install tensorflow

همراه با TensorFlow، اجازه دهید import NumPy:

import tensorflow as tf
import numpy as np

پیش پردازش تصویر با TensorFlow و Keras

ما یک مدل از قبل آموزش دیده برای طبقه بندی کلی تصاویر ارائه خواهیم داد روی ImageNet، که به ما امکان تمرکز می دهد روی را خدمت کردن process.

بیایید یک تصویر نمونه برای طبقه بندی بگیریم، مانند این تصویر از قوها در دریاچه از پیکسل ها (حق امتیاز آزاد). ما از این تصویر برای درک اینکه آیا مدل قوها، دریاچه را تشخیص می دهد یا به آن نزدیک می شود و حیوانات و طبیعت را تشخیص می دهد استفاده خواهیم کرد.

پس از دانلود، اجازه دهید مسیری را برای تصویر تعریف کنیم تا بارگذاری آن ساده شود:

img_path = 'tf_serving/pexels-artūras-kokorevas-10547480.jpg'

هنگام تغذیه تصاویر به یک مدل – می خواهیم مطمئن شویم که مراحل پیش پردازش مورد انتظار را دنبال می کنیم. اینها معمولاً شامل تغییر اندازه و تغییر مقیاس به ورودی مورد انتظار است (مبادا وزنه ها قابل استفاده نباشند)، اما گاهی اوقات شامل عادی سازی نیز می شوند. تمام مدل های Keras به همراه a preprocess_input() تابعی که ورودی آن مدل آموزش دیده را از قبل پردازش می کند.

خانواده EfficientNetV2 در چندین طعم وجود دارد – B0، B1، B2، B3، S، M و L. B0..B3 برای مقایسه با V1 خانواده است که شامل B0..B7 می شود و مدل ها با تنظیم ضرایب عرض و عمق ساخته شده اند و مدل ها را گسترده تر و عمیق تر می کند. S، M و L از کاغذ V2 می آیند، که دارای پیکربندی متفاوتی از فیلترهای ورودی و خروجی در بلوک های ساختمان هستند.

شما می توانید آنها را به عنوان دقت معامله برای سرعت در نظر بگیرید، جایی که B0 همان است سبک ترین از آنها، در حالی که L بزرگترین است.

بسته به روی سخت افزار آموزشی و استنتاج خود، می توانید نقطه شیرینی از دقت و سرعت را پیدا کنید.

تصویر قوهای Pexels در اصل دارای وضوح 5078 در 3627 پیکسل است، ما به راحتی می توانیم هر دو بعد را به 224 تغییر دهیم. معمولاً تغییر اندازه انجام می شود. در طول آموزشبنابراین کارایی در عملیات خواندن و تغییر اندازه مورد نیاز است. برای ایجاد خطوط لوله بهینه – tf.io.read_file() معمولا با tf.image عملیات:

size = (224, 224)

img = tf.io.read_file(img_path)

img = tf.image.decode_png(img, channels=3)

img = tf.expand_dims(img, 0)

img = tf.image.resize(img, size=size)

اگرچه ممکن است خواندن یک فایل پیچیده به نظر برسد – عادت به این نحو نقش مهمی در خطوط لوله داده و آموزش شما ایفا می کند.

بیایید نگاهی به تصویر بیندازیم:

import matplotlib.pyplot as plt


plt.imshow(tf.cast(tf.squeeze(img), dtype=tf.uint8))

ایجاد مدل با تنسورفلو

بیایید نمونه سازی کنیم EfficientNetV2B0:

model = tf.keras.applications.EfficientNetV2B0()

پارامترها به طور پیش‌فرض برای “راه اندازی ImageNet” هستند – به عنوان مثال وزن‌های “imagenet” بارگذاری می‌شوند، 1000 کلاس خروجی وجود دارد، و اندازه تصویر ورودی 224 است (از لحاظ تاریخی رایج‌ترین اندازه ورودی). البته می‌توانید این آرگومان‌ها را خودتان مشخص کنید، یا آن‌ها را برای تطبیق با خط لوله ورودی متفاوت تغییر دهید:

model = tf.keras.applications.EfficientNetV2B0(weights='imagenet', 
                                               classes=1000, 
                                               input_shape=(224, 224, 3))

اگر می خواهید به تمام لایه هایی که مدل دارد نگاهی بیندازید، می توانید لیستی از آنها را هنگام اجرای مدل مشاهده کنید. summary() روش:

model.summary()

این شبکه دارای 7.14 میلیون پارامتر قابل آموزش است:

=========================================================
Total params: 7,200,312
Trainable params: 7,139,704
Non-trainable params: 60,608
_________________________________________________________

از آنجایی که در این راهنما شبکه را دوباره آموزش نمی‌دهیم و تصویر آماده است، می‌توانیم پیش‌بینی کنیم!

پیشگویی

برای پیش بینی می توانیم از predict() روش و ذخیره نتایج در a preds متغیر:

preds = model.predict(x)

در عوض، می توانید به سادگی تصویر را به مدل منتقل کنید:

preds = model(x)

این preds در اینجا یک تانسور، از (batch_size, class_probabilities). از آنجایی که ما یک تصویر واحد داریم، تانسور خروجی شکل است (1, 1000)، که در آن 1000 امتیاز احتمال برای هر کلاس در ImageNet وجود دارد:

print(preds)

شما می توانید بالاترین کلاس احتمال را از طریق argmax() تابع، که برمی گرداند فهرست مطالب بالاترین مقدار در این تانسور:

tf.argmax(preds, axis=1)

در حال اجرا هستیم argmax() روی axis=1، از آنجایی که ما آن را اجرا می کنیم روی محور دوم (“ستون”) تانسور (در حال اجرا هستیم argmax() در بین 1000 احتمال کلاس). بنابراین، کلاس زیر شاخص 295 چیست؟ به طور معمول، فهرست یا فرهنگ لغتی از شاخص‌های نام کلاس‌ها را خواهید داشت که در حافظه یا در یک فایل بارگذاری شده است.

از آنجایی که ImageNet دارای کلاس های زیادی است و یک مجموعه داده/کلاس رایج برای کار با آن است، TensorFlow یک decode_predictions() روش در کنار هر مدل با انتقال پیش‌بینی‌ها به آن، نقشه برچسب را تجزیه می‌کند و 5 برچسب برتر مرتبط با 5 پیش‌بینی محتمل‌ترین و برچسب‌های قابل خواندن توسط انسان را برمی‌گرداند:

preds = preds.numpy()
tf.keras.applications.efficientnet.decode_predictions(preds)
"""
('n09332890', 'lakeside', 0.2955897), 
('n09421951', 'sandbar', 0.24374594), 
('n01855672', 'goose', 0.10379495), 
('n02894605', 'breakwater', 0.031712674), 
('n09428293', 'seashore', 0.031055905)))
"""

در خروجی بالا مشاهده می شود که شبکه معتقد است a کنار دریاچه در تصویر با بیشترین احتمال، حدود 30 درصد شانس، و پس از آن a سندبار، آ غاز، آ موج شکن و الف ساحل دریا. برجسته نیست، اما برای اولین بار به اندازه کافی خوب است. در اینجا باید در نظر بگیریم که طبقه بندی تصویر قوها آسان نیست، دارای تونالیته هایی نزدیک به هم است و تعاریف چندان روشنی از اینکه منظره به کجا ختم می شود و دریاچه یخ زده کجا شروع می شود. به خصوص، در رزولوشن های کوچکتر، تشخیص این مشکل سخت تر است.

ذخیره مدل

ایجاد و پیش‌بینی، چرخه توسعه تکراری یک مدل را شبیه‌سازی می‌کند. بیایید “نسخه فعلی” مدل را برای استقرار ذخیره کنیم.

برای سازماندهی این اطلاعات، اجازه دهید یک پوشه با نام شبکه عصبی ایجاد کنیم – به عنوان مثال، effv2b0:

$ mkdir effv2b0

اکنون، با پوشه ای برای پیگیری نسخه های ایجاد شده، باید راهی برای تمایز بین هر فایل نسخه پیدا کنیم، تا هر مدل ذخیره شده را به روشی منحصر به فرد نام گذاری کنیم. یک روش رایج برای نام‌گذاری منحصر به فرد هر فایل، استفاده از زمان ذخیره مدل بر حسب ثانیه (یا تاریخ و ثانیه کامل تقویم) است. این عدد را می توان به دست آورد time() روش در پایتون time کتابخانه

به همان روشی که قبلا انجام داده ایم، می توانیم import کتابخانه زمان، سپس زمان فعلی را بر حسب ثانیه بدست آورید:

import time

current_time = int(time.time()) 

ما یک نام برای فایل ایجاد کرده ایم، اجازه دهید مسیری را برای ذخیره آن در داخل تعریف کنیم effv2b0 پوشه با استفاده از پایتون f-string برای الحاق پوشه با شماره:

path = f"effv2b0/{current_time}"

در نهایت، ما می توانیم مدل را با استفاده از save() متد و پاس کردن مسیر به عنوان آرگومان:

model.save(path)

ساختار نهایی پوشه با فایل های مدل ذخیره شده باید به شکل زیر باشد:

# how the folder should look like
├── effv2b0
│ ├── 1673311761
│ │ ├── assets 
│ │ ├── saved_model.pb 
│ │ └── variables 

توجه داشته باشید که save() روش خروجی an assets پوشه، الف saved_model.pb فایل و الف variables پوشه این دارایی های پوشه حاوی فایل هایی است که توسط نمودار TensorFlow استفاده می شود .pb فایل (protobuf) معماری مدل و پیکربندی آموزشی و متغیرها پوشه، وزن مدل این همه آن چیزی است که TensorFlow برای اجرای یک مدل آموزش دیده نیاز دارد.

ما قبلاً مراحل اصلی تهیه یک تصویر، ایجاد مدل شبکه عصبی، پیش بینی و ذخیره یک مدل را درک کرده ایم. اکنون می توانیم ببینیم که این مدل چگونه ارائه می شود.

ارائه مدل با سرویس تنسورفلو و داکر

با انتخاب یک نسخه مدل – می‌توانیم یک تصویر Docker را برای نگهداری مدل و سرویس TF خود تنظیم کنیم و آن را مستقر کنیم.

نصب Docker

اولین قدم به process در حال نصب Docker است، در وب سایت داکر می توانید آخرین نسخه را با توجه به سیستم عامل خود دانلود کنید.

پس از دانلود و نصب، می توانیم آن را تست کنیم تا ببینیم در حال اجرا است یا خیر. شما می توانید این کار را انجام دهید روی یک خط فرمان، فقط دستور را تایپ کنید یا داخل a Jupyter دفترچه یادداشت، به همان روشی که قبلا نشان دادیم، با درج علامت تعجب ! قبل از فرمان

برای راه اندازی Docker، تایپ کرده و اجرا کنید:

$ open --background -a Docker

پس از چند ثانیه، باید پنجره برنامه Docker باز شود:

پس از شروع Docker، می توانید آن را با موارد زیر آزمایش کنید:

$ docker run hello-world

این منجر به:

Hello from Docker!
This message shows that your installation appears to be working correctly.

To generate this message, Docker took the following steps:
 1. The Docker client contacted the Docker daemon.
 2. The Docker daemon pulled the "hello-world" image from the Docker Hub.
    (arm64v8)
 3. The Docker daemon created a new container from that image which runs the
    executable that produces the output you are currently reading.
 4. The Docker daemon streamed that output to the Docker client, which sent it
    to your terminal.

To try something more ambitious, you can run an Ubuntu container with:
 $ docker run -it ubuntu bash

Share images, automate workflows, and more with a free Docker ID:
 https://hub.docker.com/

For more examples and ideas, visit:
 https://docs.docker.com/get-started/

این خروجی به این معنی است که ما آماده حرکت هستیم. Docker راه اندازی شده است!

کشیدن تصویر سرویس TF

مرحله بعدی این است که TF Serving را در داخل داکر داشته باشید – که همان است کشیدن تصویر تنسورفلو از Dockerبه عبارت دیگر، برای دانلود و بارگذاری TF Serving.

برای کشیدن تصویر TF Serving، اجرا کنید:

$ docker pull tensorflow/serving:latest-gpu

$ docker pull emacski/tensorflow-serving:latest-linux_arm64

پس از کشیدن تصویر، اگر نگاهی به برنامه دسکتاپ Docker بیندازید، در تصاویر برگه، باید یک برگه جدید وجود داشته باشد tensorflow/serving تصویر:

توجه داشته باشید که یک نیز وجود دارد hello-world تصویر از آزمایش اولیه داکر.

در خدمت مدل

تا به حال، ما یک داکر داریم container با بارگذاری TF Server در داخل آن، در نهایت می توانیم آن را اجرا کنیم. برای اجرای container، ما دستورالعمل زیر را می سازیم:

$ docker run --rm -p <port_number>:<port_number> \
        --name <container_name> \
        -v "<local_path_to_net_folder>:<internal_tfserving_path_/models/+net_folder>" \
        -e MODEL_NAME=<same_as_net_folder> \
        <name_of_pulled_image>

در دستورالعمل فوق، 5 پرچم داکر وجود دارد، --rm، -p، --name، -v، -e. معنی هر کدام این است:

• --rm: همانند حذف، به Docker می‌گوید که پاکسازی کند container پس از خروج؛
• -p: مخفف پورت، به Docker می گوید که در کدام پورت است container دویدن؛
• --name: مشخص می کند که نام آن چیست container;
• -v: کوتاه برای حجم، زمانی که با علائم کولون استفاده می شود : اولین مسیر را می سازد، یا host مسیر موجود برای تبادل اطلاعات با مسیر دوم یا مسیر داخل container. در مثال ما، این بدان معنی است که ما در حال انتقال یا کپی کردن آنچه در پوشه ما است به TF Serving’s هستیم /models/ پوشه و فعال کردن تغییرات در آن؛
• -e: مانند متغیرهای env یا محیطی، در مثال ما یک متغیر MODEL_NAME را تعریف می‌کند که در داخل container.

همچنین در دستور بالا، متن داخل < > قرار است با پورت هایی که مدل در دسترس خواهد بود جایگزین شود، نام آن container، مسیر محلی به پوشه شبکه و به دنبال آن مسیر مربوطه در سرویس TF به پوشه شبکه که در داخل یک /models/ پوشه، نام مدل و نام تصویر داکر. در زیر یک مثال آمده است:

$ docker run --rm -p 8501:8501 \
        --name tfserving_effv2 \
        -v "/Users/csamp/Documents/stack_ab/effv2b0:/models/effv2b0" \
        -e MODEL_NAME=effv2b0 \
        tensorflow/serving:latest-gpu

$ docker run --rm -p 8501:8501 \
        --name tfserving_effv2 \
        -v "/Users/csamp/Documents/stack_ab/effv2b0:/models/effv2b0" \
        -e MODEL_NAME=effv2b0 \
        emacski/tensorflow-serving:latest-linux_arm64

پس از اجرای دستور، یک خروجی طولانی را مشاهده خواهید کرد که به پایان می رسد “ورود به حلقه رویداد…”:

1402-01-17 10:01:33.219123: I external/tf_serving/tensorflow_serving/model_servers/server.cc:89) Building single TensorFlow model file config:  model_name: effv2b0 model_base_path: /models/effv2b0
1402-01-17 10:01:33.220437: I external/tf_serving/tensorflow_serving/model_servers/server_core.cc:465) Adding/updating models.
1402-01-17 10:01:33.220455: I external/tf_serving/tensorflow_serving/model_servers/server_core.cc:591)  (Re-)adding model: effv2b0
1402-01-17 10:01:33.330517: I external/tf_serving/tensorflow_serving/core/basic_manager.cc:740) Successfully reserved resources to load servable {name: effv2b0 version: 1670550215}
1402-01-17 10:01:33.330545: I external/tf_serving/tensorflow_serving/core/loader_harness.cc:66) Approving load for servable version {name: effv2b0 version: 1670550215}
1402-01-17 10:01:33.330554: I external/tf_serving/tensorflow_serving/core/loader_harness.cc:74) Loading servable version {name: effv2b0 version: 1670550215}
1402-01-17 10:01:33.331164: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:38) Reading SavedModel from: /models/effv2b0/1670550215
1402-01-17 10:01:33.465487: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:90) Reading meta graph with tags { serve }
1402-01-17 10:01:33.465524: I external/org_tensorflow/tensorflow/cc/saved_model/reader.cc:132) Reading SavedModel debug info (if present) from: /models/effv2b0/1670550215
1402-01-17 10:01:33.468611: I external/org_tensorflow/tensorflow/core/common_runtime/process_util.cc:146) Creating new thread pool with default inter op setting: 2. Tune using inter_op_parallelism_threads for best performance.
1402-01-17 10:01:33.763910: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:211) Restoring SavedModel bundle.
1402-01-17 10:01:33.781220: W external/org_tensorflow/tensorflow/core/platform/profile_utils/cpu_utils.cc:87) Failed to get CPU frequency: -1
1402-01-17 10:01:34.390394: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:195) Running initialization op روی SavedModel bundle at path: /models/effv2b0/1670550215
1402-01-17 10:01:34.516968: I external/org_tensorflow/tensorflow/cc/saved_model/loader.cc:283) SavedModel load for tags { serve }; Status: success: OK. Took 1185801 microseconds.
1402-01-17 10:01:34.536880: I external/tf_serving/tensorflow_serving/servables/tensorflow/saved_model_warmup_util.cc:59) No warmup data file found at /models/effv2b0/1670550215/assets.extra/tf_serving_warmup_requests
1402-01-17 10:01:34.539248: I external/tf_serving/tensorflow_serving/core/loader_harness.cc:87) Successfully loaded servable version {name: effv2b0 version: 1670550215}
1402-01-17 10:01:34.540738: I external/tf_serving/tensorflow_serving/model_servers/server_core.cc:486) Finished adding/updating models
1402-01-17 10:01:34.540785: I external/tf_serving/tensorflow_serving/model_servers/server.cc:133) Using InsecureServerCredentials
1402-01-17 10:01:34.540794: I external/tf_serving/tensorflow_serving/model_servers/server.cc:383) Profiler service is enabled
1402-01-17 10:01:34.542004: I external/tf_serving/tensorflow_serving/model_servers/server.cc:409) Running gRPC ModelServer at 0.0.0.0:8500 ...
(warn) getaddrinfo: address family for nodename not supported
1402-01-17 10:01:34.543973: I external/tf_serving/tensorflow_serving/model_servers/server.cc:430) Exporting HTTP/REST API at:localhost:8501 ...
(evhttp_server.cc : 245) NET_LOG: Entering the event loop ...

یعنی مدل TF سرو میشه!

شما همچنین می توانید در دسکتاپ Docker، در ظروف تب، یک خط با container نامی که در دستورالعمل ها مشخص کرده ایم --name برچسب، در این مورد، tfserving_effv2، به دنبال آن پیوند تصویر، وضعیت به عنوان در حال اجرا و پورت ها:

ارسال درخواست و دریافت پاسخ از مدل

مدل ما در حال حاضر از طریق سرویس TF در پورت 8501 قابل دسترسی است. برای اینکه بتوانیم از طریق وب به آن دسترسی داشته باشیم، باید داده ها را ارسال کنیم، یا a درخواست به مدل ارائه شده، و سپس داده ها را به صورت a دریافت کنید واکنش، پیش بینی های ما را دریافت می کنیم، و این معمولاً از طریق HTTP انجام می شود. این روش کار و ارتباط وب است. برای اینکه بتوانیم از درخواست ها و پاسخ ها استفاده کنیم، این کار را خواهیم کرد import پایتون requests کتابخانه

معمولاً هنگام ارسال پیام از طریق HTTP، پیام‌هایی با فرمت JSON ارسال می‌کنیم، زیرا هم سبک هستند و هم برای انسان بسیار قابل خواندن هستند و با پرکاربردترین زبان مطابقت دارند. روی وب – جاوا اسکریپت. از آنجایی که ما یک بار JSON نیز ارسال خواهیم کرد، این کار را خواهیم کرد import پایتون json کتابخانه:

import json
import requests

پس از وارد کردن کتابخانه‌ها، باید مکانی را که می‌خواهیم به آن دسترسی داشته باشیم، تعریف کنیم – همان آدرس جایی که مدل ما در حال ارائه است – به نام نقطه پایانی:

endpoint = 'http://localhost:8501/v1/models/effv2b0:predict'

ما در خدمت مدل هستیم روی ماشین محلی ما، از این رو localhost، اگرچه مراحل مشابهی برای ماشین مجازی راه دور نیز انجام می شود. این v1 نسخه به طور خودکار توسط TF Server ایجاد و ردیابی می شود و ما در حال دسترسی به آن هستیم predict روش از effv2b0 مدل.

بیایید نوع محتوای هدر را برای درخواست HTTP تنظیم کنیم:

header = {"content-type": "application/json"} 

آخرین کاری که باید انجام دهیم این است که داده ها را برای مدل ارسال کنیم تا پیش بینی کند، که تصویر قو از پیش پردازش شده ما خواهد بود، که با فرمت json دوباره مرتب می کنیم. json.dumps() روش. JSON حاصل:

batch_json = json.dumps({"instances": x.tolist()}) 

Tensorflow منتظر یک json با instances کلید، بنابراین نامگذاری فیلد الزامی است نمونه ها.

تا اینجا ما یک نقطه پایانی، یک هدر و یک رشته JSON با یک تصویر داریم. زمان آن رسیده است که همه آن ها را در یک درخواست وب با هم پیوند دهیم. برای این کار از requests.post() روشی که URL، داده ها، هدرها را دریافت می کند و پاسخی را برمی گرداند:

json_res = requests.post(url=endpoint, 
                         data=batch_json, 
                         headers=header)

پس از دریافت این json می توانیم با بارگذاری به محتوای آن دسترسی داشته باشیم json.loads() و دسترسی به متن آن با json_res.text. پاسخ برگشتی در قالب فرهنگ لغت است:

server_preds = json.loads(json_res.text)

سپس می‌توانیم این فرهنگ لغت پیش‌بینی سرور را به همان دیکشنری ارسال کنیم decode_predictions() روشی که قبلا استفاده کردیم فقط دو انطباق وجود دارد که باید انجام شود – اولی دسترسی به آن است predictions را در داخل دیکت قرار دهید و سپس لیست پیش بینی ها را به یک آرایه تبدیل کنید:

print('Predicted:', decode_predictions(np.array(server_preds('predictions'))))

این نتیجه در:

Predicted: ((
('n09332890', 'lakeside', 0.295589358), 
('n09421951', 'sandbar', 0.243745327), 
('n01855672', 'goose', 0.10379523), 
('n02894605', 'breakwater', 0.0317126848), 
('n09428293', 'seashore', 0.0310558397)))

در اینجا، ما همان پیش‌بینی‌هایی را داریم که در دستگاه خود انجام داده‌ایم که اکنون از طریق وب سرویس می‌شوند و به آن دسترسی داریم. ماموریت انجام شد!

کد نهایی برای دسترسی به مدل ارائه شده به شرح زیر است:

import json
import requests

endpoint = 'http://localhost:8501/v1/models/effv2b0:predict'
header = {"content-type": "application/json"} 
batch_json = json.dumps({"instances": x.tolist()})

json_res = requests.post(url=endpoint, data=batch_json, headers=header)
server_preds = json.loads(json_res.text)
print('Predicted:', decode_predictions(np.array(server_preds('predictions'))))

نتیجه

در این راهنما، ما یاد گرفتیم که یک مدل از پیش آموزش دیده تنسورفلو چیست، چگونه از آن استفاده کنیم و در چه زمینه ای از آن استفاده کنیم. ما همچنین در مورد ارائه این مدل با Docker یاد گرفته‌ایم و اینکه چرا استفاده از Docker با توجه به اهداف ما ایده خوبی است.

علاوه بر انجام تمام مراحل تبدیل تصویر، ایجاد مدل، پیش‌بینی، ذخیره حالت، سرویس‌دهی مدل و درخواست وب، ما همچنین دیدیم که استفاده از مدل دیگری در این ساختار چقدر تلاش کمی دارد.