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/
tensorflow-serving-devel

# ÔÚ±¾µØ»úÆ÷ÉÏ
mkdir ~/serving_example
cd ~/serving_example
git init
git submodule add https://github
.com/tensorflow/serving.git
tf_serving
git.submodule update - -init - -recursive

# Bazel WORKSPACEÎļþ
workspace(name = "serving")
local_repository(
name = "tf_serving",
path = _workspace_dir__ + "/tf_serving"£¬
local_repository(
name = "org_tensorflow",
path = _workspace_dir__ + "/tf_serving/
tensorflow",)
load('//tf_serving/tensorflow/
tensorflow:workspace.bzl',
'tf_workspace')
tf_workspace("tf_serving/tensorflow/",
 "@org_tensorflow")
bind(
name = "libssl",
actual = "@boringssl_git//:ssl",
)
bind(
name = "zlib",
actual = "@zlib_archive//:zlib"
£©
# ½öµ±µ¼Èëinception Ä£ÐÍʱÐèÒª
local_repository(
name = "inception_model",
path = __workspace_dir__ + "/tf_serving
/tf_models/inception¡±£¬£©
×îºó£¬ÐèÒª´ÓÈÝÆ÷ÄÚΪTensorflowÔËÐÐ
/configure:# ÔÚDockerÈÝÆ÷ÖÐ
cd /mnt/home/serving_example/tf_serving
/tensorflow
./configure

def convert_external_inputs (external_x):
 #½«ÍⲿÊäÈë±ä»»ÎªÍƶÏËùÐèµÄÊäÈë¸ñʽ
def inference(x):
 #´ÓԭʼģÐÍÖС­¡­
external_x = tf.placeholder(tf.string)
x = convert_external_inputs(external_x)
y = inference(x)

import tensorflow as tf
from tensorflow_serving.session_bundle 
import exporter
from inception import inception_model
def convert_external_inputs (external_x)
# ½«ÍⲿÊäÈë±ä»»ÎªÍƶÏËùÐèµÄÊäÈë¸ñʽ
# ½«Í¼Ïñ×Ö·û´®×ª»»ÎªÒ»¸ö¸÷·ÖÁ¿Î»ÓÚ[0,1]
ÄÚµÄÏñËØÕÅÁ¿
image =
tf.image.convert_image_dtype(tf.image.
decode_jpeg(external_x,
channels=3), tf.float32)
# ¶ÔͼÏñ³ß´ç½øÐÐËõ·Å£¬Ê¹Æä·ûºÏÄ£ÐÍÆÚÍû
µÄ¿í¶ÈºÍ¸ß¶È
images = tf.image.resize_bilinear(tf.
expand_dims(image,
0),[299,299])
# ½«ÏñËØÖµ±ä»»µ½Ä£ÐÍËùÒªÇóµÄÇø¼ä[-1,1]ÄÚ
images =tf.mul(tf.sub(image,0.5),2)
return images

def inference(images):
logits, _ = inception_model.inference

(images, 1001)return logits

saver = tf.train.Saver()
with tf.Session() as sess:
   # ´ÓѵÁ·¼ì²éµãÎļþ»Ö¸´¸÷½»Á¿
ckpt = tf.train.get_checkpoint_state
(sys.argv[1])
if ckpt and ckpt.model_checkpoint_path:
     saver.restore(sess, sys.argv[1])+¡±/¡±+
ckpt.model_checkpoint_path)
else:
      print(¡°Checkpoint file not found¡±)
      raise SystemExit

# ÔÚdockerÈÝÆ÷ÖÐ
cd/tmp
curl -O http://download.tensorflow.
org/models/image/imagenet/
inception-v3-2016-03-01.tar.gz
tar ¨Cxzf inception-v3-2016-03-01.tar.gz

Scores, class_ids=tf.nn.top_k(y,
NUM_CLASS_TO_RETURN)
#ΪÁ˼ò±ãÆð¼û£¬ÎÒÃǽ«½ö·µ»ØÀà±ðID,
Ó¦µ±ÁíÍâ¶ÔËüÃÇÃüÃû
classes =
tf.contrib.lookup.index_to_string
(tf.to_int64(class_ids)
mapping=tf.constant([str(i) for i
 in range(1001)]))

model_exporter = exporter.Exporter

(saver)
signature = exporter.classification_

signature(
input_tensor=external_x, classes_

tensor=classes,
scores_tensor=scores) model_exporter.

init(default_graph_

signature=signature,
init_op=tf.initialize_all_tables())
model_exporter.export(sys.argv[1]+

"/export"
tf.constant(time.time()), sess)

# BUILDÎļþ
py_binary£¨
   name = "export"£¬
srcs =[
  ¡°export.py¡±,
],
deps = [
¡°//tensorflow_serving/session_
bundle:exporter¡±,
¡°@org_tensorflow//tensorflow:
tensorflow_py¡±,
#½öÔÚµ¼³ö inceptionÄ£ÐÍʱÐè
¡°@inception_model//inception¡±,
],
)

# ÔÚDockerÈÝÆ÷ÖÐ
cd /mnt/home/serving_example

syntax = "proto3"£»
message ClassificationRequest {
// JPEG ±àÂëµÄͼÏñ×Ö·û´®
bytes input = 1£»
}£»
message ClassificationResponse{
    repeated ClassificationClass
 classes = 1;
};
message ClassificationClass {
string name = 1;
float score = 2;
}

message ClassificationRequest {
float petalWidth = 1;
float petaHeight = 2;
float petalWidth = 3;
float petaHeight = 4;
}

load("@protobuf//:protobuf.bzl", 
"cc_proto_library")cc_proto_library(
name="classification_service_proto",
   srcs=["classification_service.proto"],
   cc_libs = ["@protobuf//:protobuf"],
protoc="@protobuf//:protoc",
default_runtime="@protobuf//:protobuf",
use_grpc_plugin=1
)

¡­
class ClassificationService {
...
class Service : public ::grpc:
:Service {
public:
Service();
virtual ~Service();
virtual ::grpc::Status classif
y(::grpc::ServerContext*
context, const ::Classification
Request*
request, ::ClassificationRespons
e* response);
};

¡­
class ClassificationRequest :
public ::google::protobuf::
Message {
...
const ::std::string& input()
 const;void set_input(const :
:std::string& value);...}
class ClassificationResponse :
public ::google::protobuf::Message
 {...const ::ClassificationClass& 
classes() const;
void set_allocated_classes(::
ClassificationClass*
classes);
...
}
class ClassificationClass :
public ::google::protobuf::Message {
...
const ::std::string& name() const;
void set_name(const ::std::string&
 value);
float score() const;
void set_score(float value);
...
}

#include <iostream>
#include <memory>
#include <string>

#include <grpc++/grpc++.h>
#include "classification_service.

grpc.pb.h"

#include "tensorflow_serving/

servables/tensorflow/
session_bundle_factory.h"

using namespace std;
using namespace tensorflow::

serving;
using namespace grpc;

unique_ptr<SessionBundle> create

SessionBundle(const string&
pathToExportFiles) {
SessionBundleConfig session_bundl

e_config =
SessionBundleConfig();
unique_ptr<SessionBundleFactory>

bundle_factory;
SessionBundleFactory::Create(session

_bundle_config,
&bundle_factory);

unique_ptr<SessionBundle> session

Bundle;
bundle_factory-
>CreateSessionBundle(pathToExportFiles,

&sessionBundle);

return sessionBundle;
}

class ClassificationServiceImpl 
final : public
ClassificationService::Service {

private:
unique_ptr<SessionBundle> session

Bundle;public:
ClassificationServiceImpl(unique_ptr

<SessionBundle>
sessionBundle) :
sificationServiceImpl(unique_ptr<Sessi
Status classify(ServerContext* context,

constClassificationRequest* request,
ClassificationResponse* response)
override {
// ¼ÓÔØ·ÖÀàÇ©Ãû
ClassificationSignature signature;
const tensorflow::Status signature

Status =GetClassificationSignature

(sessionBundle->meta_graph_def,

&signature);
if (!signatureStatus.ok()) {
return Status(StatusCode::INTERNAL,
signatureStatus.error_message());
}
// ½« protobuf ÊäÈë±ä»»ÎªÍƶÏÊäÈëÕÅÁ¿
tensorflow::Tensor
input(tensorflow::DT_STRING, tensorflo

w::TensorShape());input.scala

r<string>()() = request->input();

vector<tensorflow::Tensor> outputs;
//ÔËÐÐÍƶÏ
const tensorflow::Status inference

Status =sessionBundle->session->Run(
{{signature.input().tensor_name(),
input}},
{signature.classes().tensor_name(),
signature.scores().tensor_name()},
{},
&outputs);

if (!inferenceStatus.ok()) {
return Status(StatusCode::INTERNAL,
inferenceStatus.error_message());
}
//½«ÍƶÏÊä³öÕÅÁ¿±ä»»ÎªprotobufÊä³ö
for (int i = 0; i <
outputs[0].vec<string>().size();

++i) {ClassificationClass
*classificationClass = response->

add_classes();classificationClass-
>set_name(outputs[0].flat<string>

()(i));classificationClass-
>set_score(outputs[1].flat<float

>()(i));}return Status::OK;
}
};

int main(int argc, char** argv) {
if (argc < 3) {
    cerr << "Usage: server <port> 
/path/to/export/files" <<
endl;
            return 1;
}
    const string serverAddres
s(string("0.0.0.0:") +
argv[1]);
    const string pathToExportFile 
(argv[2]) ;

unique_ptr<SessionBundle>

sessionBundle =
createSessionBundle(pathToExportFiles);

const string serverAddres
classificationServiceImpl(move

(sessionBundle));

ServerBuilder builder;
builder. AddListeningPort(serverAddress,
grpc::InsecureServerCredentials());
builder.RegisterService(&classifi

cationServiceImpl);

unique_ptr<Server> server = builder

.BuildAndStart();
cout << "Server listening on " <<

serverAddress << endl;

server->Wait();
return 0;
}
ΪÁ˱àÒëÕâ¶Î´úÂ룬ÐèÒªÔÚBUILDÎļþÖÐ

ΪÆ䶨ÒåÒ»Ìõ¹æÔò£º
cc_binary(
name = "server",
srcs = [
"server.cc",
],
deps = [
":classification_service_proto",
"@tf_serving//tensorflow_serving/

servables/
tensorflow:session_bundle_factory",
"@grpc//:grpc++",
],
£©

Hello World!

From BaseHTTPServer import HTTPServer
,BaseHTTPRequestHandler
import cgi
import classification_service_pb2
From grpc.beta import implementations

class ClientApp (BaseHTTPRequestHandler);
def do_GET(self):
self.respond_form()

def respond_form(self, response=""):

form = """
<html><body>
<h1>Image classification service

</h1>
<form enctype="multipart/form-data"

method="post">
<div>Image: <input type="file" name="file"
accept="image/jpeg"></div>
<div><input type="submit" value="Upload">

</div>
</form>
%s
</body></html>
"""

response = form % response

self.send_response(200)
self.send_header("Content-type",

"text/html")
self.send_header("Content-length",

len(response))
self.end_headers()
self.wfile.write(response)

pip install grpcio cython
 grpcio-tools
python -m grpc.tools.protoc
 -I. --python_out=. --
grpc_python_out=. classification_
service.proto

def do_POST(self):
   form = cgi.FieldStorage(
fp=self.rfile,
headers=self.headers,
environ={
'REQUEST_METHOD': 'POST',
'CONTENT_TYPE': self.headers
['Content-Type'],
})
   request =
classification_service_pb2.Classi
ficationRequest()
request.input = form['file'].file.read()

channel =
implementations.insecure_channel

("127.0.0.1", 9999)
stub =
classification_service_pb2.beta_create

_ClassificationService_stub(channel)
response = stub.classify(request, 10) # 10 secs
timeout
self.respond_form("<div>Response: %s</div>" %
response)

#ÔÚÈÝÆ÷ÄÚ²¿
mkdir /opt/classification_server
cd /mnt/home/serving_example
cp -R bazel-bin/. /opt/class
ification_server
bazel clean

#ÔÚÈÝÆ÷Íⲿ
docker ps
#»ñÈ¡ÈÝÆ÷ID
docker commit <container id>