機械知能のための TensorFlow 実践: 製品環境へのモデルの導入

TesnsorFlow を使用して、基本的な機械学習モデルから複雑なディープラーニングネットワークまで、さまざまなモデルを構築およびトレーニングする方法を理解した後は、トレーニングしたモデルを製品に組み込んで他のアプリケーションで使用できるようにする方法を検討する必要があります。この記事では、これについて詳しく紹介します。この記事は、「TensorFlow Practice for Machine Intelligence」の第 7 章から抜粋したものです。

この記事では、ユーザーが画像をアップロードし、その画像に対して Inception モデルを実行して画像を自動的に分類できるシンプルな Web アプリを作成します。

TensorFlowサービス開発環境を構築する

Docker イメージ

TensorFlow Serving は、製品で提供されるモデルをユーザーが使用できるようにするサーバーを構築するためのツールです。開発中にこのツールを使用するには、すべての依存関係とツールを手動でインストールしてソースからビルドする方法と、Docker イメージを使用する方法の 2 つがあります。後者の方がより簡単かつクリーンであり、Linux 以外の環境での開発も可能なので、後者を使用します。

Docker イメージに詳しくない場合は、完全なオペレーティングシステムを内部で実行する必要のない軽量の仮想マシンイメージと考えてください。 Docker がまだインストールされていない場合は、開発マシンにインストールしてください。詳細なインストール手順を確認するには、ここをクリックしてください (https://docs.docker.com/engine/installation/)。

Docker イメージを使用するには、ローカルでイメージを作成するための設定ファイルである、作者が提供しているファイル (https://github.com/tensorflow/serving/blob/master/tensorflow_serving/tools/docker/Dockerfile.devel) を使用することもできます。このファイルを使用するには、次のコマンドを使用します。

 docker build --pull -t $USER/tensorflow-serving-devel   
 
 https://raw.githubusercontent.com/tensorflow/serving/master/ 
 
 tensorflow_serving/tools/docker/Dockerfile.devel

上記のコマンドを実行した後、すべての依存関係をダウンロードするのに長い時間がかかる場合があることに注意してください。

上記のコマンドを実行した後、このイメージを使用してコンテナを実行するには、次のコマンドを入力します。

 docker run -v $HOME:/mnt/home -p 9999:9999 -it $ USER / 
 
テンソルフローサービング開発

このコマンドは、ホームディレクトリをコンテナーの /mnt/home パスに読み込み、その内部のターミナルで作業できるようにします。これは、ビルドツールを実行するときにのみコンテナーを使用しながら、お気に入りの IDE またはエディターを使用してコードを直接編集できるため、非常に便利です。また、ポート 9999 も開かれるので、独自のホストからアクセスでき、後で構築するサーバーで使用できるようになります。

exit コマンドを入力してコンテナターミナルを終了し、実行を停止します。必要に応じて上記のコマンドを使用して起動することもできます。

Bazel ワークスペース

TensorFlow サービングプログラムは C++ で記述されているため、Google の Bazel ビルドツールを使用してビルドする必要があります。最近作成したコンテナ内から Bazel を実行します。

Bazel はコードレベルでサードパーティの依存関係を管理し、それらも Bazel でビルドする必要がある場合は自動的にダウンロードしてビルドします。プロジェクトがサポートするサードパーティの依存関係を定義するには、プロジェクトリポジトリのルートディレクトリに WORKSPACE ファイルを定義する必要があります。

必要な依存関係は TensorFlow Serving ライブラリです。私たちの場合、TensorFlow モデルリポジトリには Inception モデルのコードが含まれています。

残念ながら、この記事の執筆時点では、TensorFlow Serving は Bazel が直接参照する Git リポジトリとしてはまだサポートされていないため、プロジェクトに Git サブモジュールとして含める必要があります。

 # ローカルマシン上
 
 mkdir ~/serving_example 
 
 cd ~/serving_example 
 
 git 初期化
 
 git サブモジュールを追加https://github.com/tensorflow/serving.git 
 
 tf_serving 
 
 git.submodule更新- -init - -recursive

次に、WORKSPACE ファイルの local_repository ルールを使用して、サードパーティの依存関係をローカルに保存されたファイルとして定義します。さらに、プロジェクトからインポートされた tf_workspace ルールを使用して、TensorFlow の依存関係を初期化する必要があります。

 Bazel WORKSPACE ファイル
 
ワークスペース(名前= "serving" ) 
 
ローカルリポジトリ( 
 
名前= "tf_serving" 、 
 
パス = _workspace_dir__ + "/tf_serving" 、 
 
ローカルリポジトリ( 
 
名前= "org_tensorflow" 、 
 
パス = _workspace_dir__ + "/tf_serving/tensorflow" 、 
 
 ） 
 
ロード( '//tf_serving/tensorflow/tensorflow:workspace.bzl' 、 
 
 'tf_workspace' ) 
 
 tf_workspace( "tf_serving/tensorflow/" 、 "@org_tensorflow" ) 
 
バインド（ 
 
名前= "libssl" 、 
 
実際 = "@boringssl_git//:ssl" 、 
 
 ） 
 
バインド（ 
 
名前= "zlib" 、 
 
実際 = "@zlib_archive//:zlib"   
 
 ） 
 
 # インセプションモデルをインポートする場合にのみ必要
 
ローカルリポジトリ( 
 
名前= "inception_model" 、 
 
パス = __workspace_dir__ + "/tf_serving/tf_models/ 
 
 「インセプション」、 
 
 ） 
 
最後に、コンテナ内から Tensorflow の ./configure を実行する必要があります。 
 
 # Dockerコンテナ内
 
 cd /mnt/home/serving_example/tf_serving/tensorflow 
 
 ./configure

トレーニング済みモデルをエクスポートする

モデルのトレーニングが完了し、評価の準備ができたら、データフローグラフとその変数値をエクスポートして、本番環境で使用できるようにする必要があります。

モデルのデータフローグラフは、プレースホルダーから入力を受け取り、それらに対して単一の推論ステップを実行して出力を計算する必要があるため、トレーニングバージョンとは異なる必要があります。 Inception モデルの例や一般的な画像認識モデルでは、入力を JPEG エンコードされた画像を表す文字列にして、それを消費アプリに簡単に渡せるようにする必要があります。これは、TFRecord ファイルからトレーニング入力を読み取ることとはまったく異なります。

入力を定義する一般的な形式は次のとおりです。

 def convert_external_inputs(external_x): 
 
 #外部入力を推論に必要な入力形式に変換する
 
定義推論(x): 
 
 #オリジナルモデルより… 
 
 external_x = tf.placeholder(tf.string) 
 
 x = convert_external_inputs(外部x) 
 
 y = 推論(x)

上記のコードでは、入力に対してプレースホルダーが定義され、プレースホルダーによって表される外部入力を元の推論モデルに必要な入力形式に変換する関数が呼び出されます。たとえば、JPEG 文字列を Inception モデルに必要な画像形式に変換する必要があります。最後に、元のモデル推論メソッドが呼び出され、変換された入力に基づいて推論結果が取得されます。

たとえば、Inception モデルの場合、次のメソッドが必要です。

テンソルフローをtfとしてインポートする
 
 tensorflow_serving.session_bundleのインポート エクスポーター
 
 inception_modelからインポート
 
デフconvert_external_inputs(external_x) 
 
 # 外部入力を推論に必要な入力形式に変換する
 
 # 画像文字列を [0,1] の成分を持つピクセルテンソルに変換します
 
画像 = 
 
 tf.image.convert_image_dtype(tf.image.decode_jpeg(external_x, 
 
チャンネル=3)、tf.float32) 
 
 # モデルが想定する幅と高さに合わせて画像サイズを拡大縮小します
 
画像 = tf.image.resize_bilinear(tf.expand_dims(画像, 
 
 0),[299,299]) 
 
 # ピクセル値をモデルに必要な区間[-1,1]に変換する
 
画像 = tf.mul(tf.sub(画像,0.5),2) 
 
画像を返す
 
 
 def推論(画像): 
 
  ロジット、_ = inception_model.inference(画像、1001) 
 
リターンロジット

この推論方法では、すべてのパラメータに値を割り当てる必要があります。これらのパラメータ値をトレーニングチェックポイントから復元します。前の章では、モデルのトレーニングチェックポイントファイルを定期的に保存したことを覚えているかもしれません。これらのファイルには、その時点で学習したパラメータが含まれているため、異常が発生してもトレーニングの進行には影響しません。

トレーニングの終了時に、最後に保存されたトレーニングチェックポイントファイルには、最後に更新されたモデルパラメータが含まれます。これが本番環境で使用するバージョンです。

チェックポイントファイルを復元するには、次のコードを使用します。

セーバー = tf.train.Saver() 
 
 tf.Session()を sessとして使用: 
 
   # トレーニングチェックポイントファイルからトランザクションを復元する
 
 ckpt = tf.train.get_checkpoint_state(sys.argv[1]) 
 
 ckptおよびckpt.model_checkpoint_path の場合: 
 
     saver.restore(sess, sys.argv[1])+”/”+ 
 
 ckpt.model_checkpoint_path) 
 
それ以外： 
 
      print("チェックポイントファイルが見つかりません") 
 
      SystemExit を起動する

Inception モデルの場合、事前トレーニング済みのチェックポイントファイルを次のリンクからダウンロードできます: http://download.tensorflow.org/models/image/imagenet/inception-v3-2016-03-01.tar.gz。

 # Dockerコンテナ内
 
 cd/tmp 
 
 curl -O http://download.tensorflow.org/models/image/imagenet/ 
 
インセプション-v3-2016-03-01.tar.gz 
 
 tar –xzf インセプション-v3-2016-03-01.tar.gz

最後に、tensorflow_serving.session_bundle.exporter.Exporter クラスを使用してモデルをエクスポートします。セーバーインスタンスを渡すことでそのインスタンスを作成します。次に、exporter.classification_signature メソッドを使用してモデルの署名を作成する必要があります。このシグネチャは、input_tensor が何で、出力テンソルが何であるかを指定します。出力は、出力クラス名のリストを含む classes_tensor と、モデルが各クラスに割り当てたスコア (または確率) を含む socres_tensor で構成されます。通常、カテゴリの数がかなり多いモデルでは、tf.nn.top_k によって選択されたカテゴリのみ、つまりモデルによって割り当てられたスコアの降順で上位 K 個のカテゴリのみが返されるように構成で指定する必要があります。

最後のステップは、exporter.Exporter.init メソッドを呼び出し、出力パス、モデルバージョン番号、およびセッションオブジェクトを受け取る export メソッドを介してモデルをエクスポートするこのシグネチャを適用することです。

スコア、class_ids=tf.nn.top_k(y,NUM_CLASS_TO_RETURN) 
 
 #簡単にするために、カテゴリIDのみを返します。カテゴリIDは別々に名前を付ける必要があります。 
 
クラス = 
 
 tf.contrib.lookup.index_to_string(tf.to_int64(クラスID) 
 
マッピング = tf.constant([str(i) for i in range(1001)])) 
 
 
 model_exporter = exporter.Exporter(saver) 
 
署名 = exporter.classification_signature( 
 
   input_tensor=external_x、classes_tensor=クラス、 
 
 scores_tensor=スコア) 
 
 model_exporter.init(default_graph_signature=署名、 
 
 init_op = tf.initialize_all_tables()) 
 
   model_exporter.export(sys.argv[1]+ "/export"   
 
 tf.constant(時間.時間()), sess)

Exporter クラスコードには自動生成されたコードへの依存関係があるため、Docker コンテナー内で bazel を使用してエクスポーターを実行する必要があります。

これを行うには、先ほど起動した bazel ワークスペースの exporter.py にコードを保存する必要があります。さらに、次のようなビルドルールを含む BUILD ファイルが必要になります。

 # ビルドファイル
 
 py_binary（ 
 
名前= "エクスポート" 、 
 
ソース =[ 
 
  「エクスポート.py」、 
 
 ]、 
 
依存関係 = [ 
 
 "//tensorflow_serving/session_bundle:エクスポーター", 
 
 "@org_tensorflow//tensorflow:tensorflow_py", 
 
 #インセプションモデルをエクスポートする場合にのみ必要
 
 「@inception_model//インセプション」、 
 
 ]、 
 
 ）

次のコマンドを使用して、コンテナ内でエクスポーターを実行できます。

 # Dockerコンテナ内
 
 cd /mnt/home/serving_example

/tmp/inception-v3 から抽出できるチェックポイントファイルに基づいて、/tmp/inception-v3/{current_timestamp}/ にエクスポーターを作成します。

初めて実行するときには TensorFlow をコンパイルする必要があるため、時間がかかることに注意してください。

サーバーインターフェースの定義

次に、エクスポートされたモデル用のサーバーを作成する必要があります。

TensorFlow Serving は gRPC プロトコルを使用します (gRPC は HTTP/2 に基づくバイナリプロトコルです)。サーバーを作成するためのさまざまな言語をサポートし、クライアントスタブを自動的に生成します。 TensorFlow は C++ に基づいているため、独自のサーバーを定義する必要があります。幸いなことに、サーバー側のコードは比較的短いです。

gRPS を使用するには、gRPC の IDL (インターフェイス定義言語) およびバイナリエンコーディングであるプロトコルバッファーでサービスコントラクトを定義する必要があります。私たちのサービスを定義しましょう。前のエクスポートセクションで説明したように、JPEG エンコードされた画像文字列を入力として受け取り、分類してスコア順にランク付けされた推定カテゴリのリストを返すサービスが必要です。

このようなサービスは、次のように、classification_service.proto ファイルで定義する必要があります。

構文 = "proto3" ; 
 
メッセージ分類要求 { 
 
 //JPEG エンコードされた画像文字列
 
バイト入力 = 1; 
 
 }; 
 
メッセージ分類応答{ 
 
    繰り返される ClassificationClass クラス = 1; 
 
 }; 
 
メッセージ分類クラス { 
 
文字列名= 1; 
 
フロートスコア = 2; 
 
 }

画像、オーディオクリップ、またはテキストを受信できるあらゆる種類のサービスに同じインターフェイスを使用できます。

データベースレコードのような構造化された入力を使用するには、ClassificationRequest メッセージを変更する必要があります。たとえば、Iris データセットの分類サービスを構築しようとする場合は、次のようなコードを記述します。

メッセージ分類要求 { 
 
フロート花びらの幅 = 1; 
 
フロートペタの高さ = 2; 
 
フロート花びらの幅 = 3; 
 
フロートペタの高さ = 4; 
 
 }

この proto ファイルは、proto コンパイラによってクライアントとサーバーの対応するクラス定義に変換されます。 protobuf コンパイラを使用するには、次のような新しいルールを BUILD ファイルに追加する必要があります。

ロード( "@protobuf//:protobuf.bzl" 、 "cc_proto_library" ) 
 
 cc_proto_library( 
 
名前= "classification_service_proto" 、 
 
 srcs = [ "classification_service.proto" ], 
 
 cc_libs = [ "@protobuf//:protobuf" ], 
 
 protoc = "@protobuf//:protoc" 、 
 
 default_runtime = "@protobuf//:protobuf" 、 
 
使用_grpc_plugin=1 
 
 ）

上記のコードスニペットの上部にある負荷に注意してください。外部からインポートされた protobuf ライブラリから cc_proto_library ルール定義をインポートします。次に、それを使用して proto ファイルのビルドルールを定義します。 bazel build :classification_service_proto を使用してビルドを実行し、bazel-genfiles/classification_service.grpc.pb.h を通じて結果を検査します。

 … 
 
クラス分類サービス { 
 
 ... 
 
クラスService: public ::grpc::Service{ 
 
公共： 
 
サービス（）; 
 
仮想 ~Service(); 
 
仮想 ::grpc::Status 分類(::grpc::ServerContext* 
 
コンテキスト、const ::ClassificationRequest* 
 
リクエスト、::ClassificationResponse* レスポンス); 
 
 };

推論ロジックによれば、ClassificationService::Service は実装する必要があるインターフェースです。 bazel-genfiles/classification_service.pb.h をチェックすることで、リクエストメッセージとレスポンスメッセージの定義を確認することもできます。

 … 
 
クラス ClassificationRequest: 
 
パブリック::google::protobuf::Message { 
 
 ... 
 
 const ::std::string& input() const; 
 
 void set_input(const ::std::string& 値); 
 
 ... 
 
 } 
 
クラス ClassificationResponse: 
 
パブリック::google::protobuf::Message { 
 
 ... 
 
 const ::ClassificationClass& classes() const; 
 
 void set_allocated_classes(::ClassificationClass* 
 
クラス); 
 
 ... 
 
 } 
 
クラス分類クラス: 
 
パブリック::google::protobuf::Message { 
 
 ... 
 
 const ::std::string&名前()const; 
 
 void set_name(const ::std::string& 値); 
 
浮動小数点スコア() 定数; 
 
 void set_score(浮動小数点値); 
 
 ... 
 
 }

ご覧のとおり、proto 定義は各型の C++ クラスインターフェイスになりました。それらの実装も自動的に生成されるため、直接使用できます。

推論サーバーの実装

ClassificationService::Service を実装するには、エクスポートされたモデルをロードし、その上で推論メソッドを呼び出す必要があります。これは、エクスポートされたモデルから作成され、完全にロードされたデータフローグラフを含む TF Session オブジェクトと、エクスポーターで定義された分類シグネチャを含むメタデータを含む SessionBundle オブジェクトを通じて実現されます。

エクスポートされたファイルパスから SessionBundle オブジェクトを作成するには、この定型句を処理する便利な関数を定義します。

 #include <iostream> 
 
 #include <メモリ> 
 
 #include <文字列> 
 
 
 #include <grpc++/grpc++.h> 
 
 #include "classification_service.grpc.pb.h"   
 
 
 #include "tensorflow_serving/servables/tensorflow/ 
 
セッションバンドルファクトリー.h" 
 
 
名前空間 std を使用します。 
 
名前空間 tensorflow::serving を使用します。 
 
名前空間 grpc を使用します。 
 
 
 unique_ptr<SessionBundle> createSessionBundle(const string& 
 
エクスポートファイルのパス) { 
 
セッションバンドル構成 session_bundle_config = 
 
セッションバンドル構成(); 
 
 unique_ptr<SessionBundleFactory> バンドルファクトリ; 
 
 SessionBundleFactory::作成(session_bundle_config、 
 
 &バンドルファクトリー); 
 
 
        unique_ptr<セッションバンドル> セッションバンドル; 
 
バンドルファクトリー - 
 
 >CreateSessionBundle(pathToExportFiles, &sessionBundle); 
 
 
 sessionBundleを返します。 
 
 }

このコードでは、SessionBundleFactory クラスを使用して SessionBundle オブジェクトを作成し、pathToExportFiles で指定されたパスからエクスポートされたモデルを読み込むように構成します。最後に、作成された SessionBundle インスタンスへの一意のポインターが返されます。

次に、推論で使用するパラメータとして SessionBundle インスタンスを受け取るサービスである ClassificationServiceImpl の実装を定義する必要があります。

クラス ClassificationServiceImpl 最終:パブリック  
 
分類サービス::サービス { 
 
プライベート： 
 
 unique_ptr<セッションバンドル> セッションバンドル; 
 
公共： 
 
分類サービス実装(unique_ptr<セッションバンドル> 
 
セッションバンドル): 
 
 sificationServiceImpl(unique_ptr<SessionImpl 
 
ステータス分類(ServerContext* context, const 
 
 ClassificationRequest* リクエスト、 
 
分類応答* 応答) 
 
オーバーライド { 
 
 // カテゴリシグネチャをロードする
 
分類署名署名; 
 
 const tensorflow::Status シグネチャStatus = 
 
 GetClassificationSignature(セッションバンドル- 
 
 >meta_graph_def、&署名); 
 
署名ステータスがok()の場合{ 
 
ステータスを返す(StatusCode::INTERNAL, 
 
署名ステータス.error_message()); 
 
 } 
 
 // protobuf 入力を推論入力テンソルに変換する
 
テンソルフロー::テンソル
 
入力(tensorflow::DT_STRING、tensorflow::TensorShape()); 
 
 input.scalar<文字列>()() = request->input(); 
 
 vector<tensorflow::Tensor> 出力; 
 
 //推論を実行する
 
 const tensorflow::Status 推論Status = 
 
 sessionBundle->session->実行( 
 
 {{signature.input().tensor_name(), 
 
入力}}、 
 
 {署名.クラス().テンソル名(), 
 
 signature.scores().tensor_name()}, 
 
 {}, 
 
 &出力); 
 
推論ステータスがokの場合
 
ステータスを返す(StatusCode::INTERNAL, 
 
推論ステータス.error_message()); 
 
 } 
 
 //推論出力テンソルをprotobuf出力に変換する
 
 ( int i = 0 ; i < 
 
出力[0].vec<文字列>(). size (); ++i) { 
 
分類クラス
 
 *classificationClass = レスポンス->add_classes(); 
 
分類クラス- 
 
 >set_name(outputs[0].flat<文字列>()(i)); 
 
分類クラス- 
 
 >set_score(outputs[1].flat< float >()(i)); 
 
 } 
 
 Status::OKを返します。 
 
 } 
 
 };

分類メソッドの実装には、次の 4 つのステップが含まれます。

GetClassificationSignature 関数を使用して、モデルのエクスポートメタデータに保存されている分類署名を読み込みます。このシグネチャは、入力テンソルの (論理) 名から受信した画像の実際の名前へのマッピングと、データフローグラフ内の出力テンソルの (論理) 名からそれらに対して取得された推論結果へのマッピングを指定します。
JPEG でエンコードされた画像文字列を、リクエストパラメータから推論に使用されるテンソルにコピーします。
推論を実行します。 sessionBundle から TF セッションオブジェクトを取得し、入力テンソルと出力テンソルの両方を渡して推論を 1 回実行します。
出力テンソルの結果を、ClassificationResponse メッセージで指定された形状で応答出力パラメータにコピーし、フォーマットします。

最後のコードは、gRPC サーバーをセットアップし、ClassificationServiceImpl (Session-Bundle オブジェクトで構成される) のインスタンスを作成する定型コードです。

 int main( int argc, char ** argv) { 
 
 （引数<3）の場合{ 
 
    cerr << "使用法: server <port> /path/to/export/files" << 
 
終わり; 
 
 1 を返します。 
 
 } 
 
    定数文字列サーバアドレス(文字列( "0.0.0.0:" ) + 
 
 argv[1]); 
 
    定数文字列pathToExportFile(argv[2]); 
 
 
    unique_ptr<セッションバンドル> セッションバンドル = 
 
セッションバンドルを作成します(エクスポートファイルのパス)。 
 
 
    定数文字列 serverAddress 
 
分類サービス実装((セッションバンドル)を移動します); 
 
 
 ServerBuilder ビルダー; 
 
ビルダー.AddListeningPort(サーバーアドレス、 
 
 grpc::InsecureServerCredentials(); のようになります。 
 
    ビルダー。RegisterService(&classificationServiceImpl); 
 
 
    unique_ptr<Server> server = builder.BuildAndStart(); 
 
 cout << "サーバーは " << serverAddress << endl; 
 
 
    サーバー->Wait(); 
 
 0を返します。 
 
 }

このコードをコンパイルするには、BUILD ファイルでルールを定義する必要があります。

 cc_binary( 
 
名前= "サーバー" 、 
 
ソース = [ 
 
 「server.cc」 、 
 
 ]、 
 
依存関係 = [ 
 
 ":classification_service_proto" 、 
 
 "@tf_serving//tensorflow_serving/servables/ 
 
テンソルフロー:セッションバンドルファクトリー", 
 
 "@grpc//:grpc++" 、 
 
 ]、 
 
 ）

このコードを使用すると、コマンド bazel run :server 9999 /tmp/inception-v3/export/{timestamp} を使用して、コンテナーから推論サーバーを実行できます。

クライアントアプリケーション

gRPC は HTTP/2 をベースとしているため、将来的にはブラウザから直接 gRPC ベースのサービスを呼び出すことが可能になる可能性がありますが、主流のブラウザが必要な HTTP/2 機能をサポートし、Google がブラウザ側の JavaScript gRPC クライアントプログラムをリリースしない限り、Web アプリからの推論サービスへのアクセスはサーバー側のコンポーネントを介して行う必要があります。

次に、BaseHTTPServer をベースにしたシンプルな Python Web サーバーを構築します。このサーバーは、アップロードされた画像ファイルを処理し、処理のために推論サービスに送信し、推論結果をプレーンテキストで返します。

分類のために推論サーバーに画像を送信する場合、サーバーは簡単なフォームで GET リクエストに応答します。使用されるコードは次のとおりです。

 BaseHTTPServerからHTTPServer、BaseHTTPRequestHandler をインポートします。 
 
 cgiをインポートする
 
インポート分類サービスpb2 
 
 grpc.beta インポート実装から
 
 
クラス ClientApp (BaseHTTPRequestHandler); 
 
   def do_GET(self): 
 
自己応答フォーム() 
 
 
   def respond_form(self, レスポンス = "" ): 
 
 
      フォーム = "" " 
 
 <html><本文> 
 
 <h1>画像分類サービス</h1> 
 
 <form enctype= "multipart/form-data" method= "post" > 
 
 <div>画像: <input type= "file"  名前= "ファイル"   
 
 accept= "画像/jpeg" </div> 
 
      <div><input type= "submit" value= "アップロード" ></div> 
 
 </フォーム> 
 
 %s 
 
 </body></html> 
 
 「」 「 」 
 
 
レスポンス = フォーム % レスポンス
 
 
自己応答を送信(200) 
 
 self.send_header( "コンテンツタイプ" , "text/html" ) 
 
 self.send_header( "コンテンツの長さ" , len(応答)) 
 
自己終了ヘッダー() 
 
 self.wfile.write(レスポンス)

Web アプリサーバーから推論機能を呼び出すには、ClassificationService の対応する Python プロトコルバッファークライアントが必要です。これを生成するには、Python プロトコルバッファコンパイラを実行します。

 pip で grpcio cython grpcio-tools をインストールします
 
 python -m grpc.tools.protoc -I. --python_out=. --   
 
 grpc_python_out=. 分類サービス.proto

サービスを呼び出すために使用されるスタブを含む classified_service_pb2.py ファイルが生成されます。

POST リクエストを受信すると、サーバーは送信されたフォームを解析し、それを使用して Classification-Request オブジェクトを作成します。次に、この分類サーバーのチャネルを設定し、そのチャネルにリクエストを送信します。最後に、分類された応答を HTML としてレンダリングし、ユーザーに返します。

 def do_POST(self): 
 
   フォーム = cgi.FieldStorage( 
 
 fp=self.rファイル、 
 
ヘッダー=self.headers、 
 
環境={ 
 
 'REQUEST_METHOD' : 'POST' 、 
 
 'CONTENT_TYPE' : self.headers[ 'コンテンツタイプ' ], 
 
 }) 
 
   リクエスト = 
 
分類サービスpb2.分類リクエスト() 
 
 request.input = フォーム[ 'file' ].file.read ( ) 
 
 
チャンネル = 
 
実装.安全でないチャネル( "127.0.0.1" , 9999) 
 
スタブ = 
 
分類サービス_pb2.beta_create_ClassificationService_stub(チャネル) 
 
 response = stub.classify(request, 10) # 10秒
 
タイムアウト
 
 self.respond_form( "<div>レスポンス: %s</div>" % 
 
応答）

サーバーを実行するには、コンテナの外部から python client.py コマンドを使用します。次に、ブラウザで http://localhost:8080 に移動して UI にアクセスします。画像をアップロードして推論がどのように機能するかを確認してください。

製品の準備

この記事を締めくくる前に、分類サーバーを本番環境に適用する方法についても学習します。

まず、コンパイルされたサーバーファイルをコンテナー内の永続的な場所にコピーし、一時的なビルドファイルをすべてクリーンアップします。

 #コンテナ内
 
 mkdir /opt/classification_server 
 
 cd /mnt/home/serving_example 
 
 cp -R bazel-bin/. /opt/classification_server 
 
バゼルクリーン

ここで、コンテナの外部で、その状態を新しい Docker イメージにコミットする必要があります。これは基本的に、仮想ファイルシステムへの変更を記録するスナップショットを作成することを意味します。

 #コンテナ外
 
ドッカーps 
 
 #コンテナIDを取得する
 
 docker commit <コンテナID>

この方法では、イメージを好みの Docker サービスクラウドにプッシュして提供することができます。

結論

この記事では、トレーニング済みのモデルを提供する方法、それらをエクスポートする方法、そしてこれらのモデルを実行できる高速で軽量なサーバーを構築する方法について学びました。また、他のアプリから TensorFlow モデルを使用するための完全なツールセットを使用して、これらのモデルを使用するシンプルな Web アプリを作成する方法も学びました。

<<: 中国のAI研究は米国を上回る？専門家：例えば、ディープラーニングに関する論文の発表数

>>: 敵対的サンプルとディープニューラルネットワークの学習