TensorFlow部署：使用TF Serving为TensorFlow模型提供服务_found untraced functions such as _jit_compiled_con

import os
import json
import shutil
import requests
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt

# Using MobileNet from Keras Applications
model = tf.keras.applications.MobileNet()

def preprocess(image, mean=0.5, std=0.5, shape=(224, 224)):
    """Scale, normalize and resizes images."""
    image = image / 255.0  # Scale
    image = (image - mean) / std  # Normalize
    image = tf.image.resize(image, shape)  # Resize
    return image

# Download human-readable labels for ImageNet.
imagenet_labels_url = (
    "https://storage.googleapis.com/download.tensorflow.org/data/ImageNetLabels.txt"
)
response = requests.get(imagenet_labels_url)
# Skiping backgroung class
labels = [x for x in response.text.split("\n") if x != ""][1:]
# Convert the labels to the TensorFlow data format
tf_labels = tf.constant(labels, dtype=tf.string)
 
 
def postprocess(prediction, labels=tf_labels):
    """Convert from probs to labels."""
    indices = tf.argmax(prediction, axis=-1)  # Index with highest prediction
    label = tf.gather(params=labels, indices=indices)  # Class name
    return label

# Download the image from the URL
response = requests.get("https://i.imgur.com/j9xCCzn.jpeg", stream=True)
 
# Save the downloaded image to a local file
with open("banana.jpeg", "wb") as f:
    shutil.copyfileobj(response.raw, f)
 
# Read the saved image using matplotlib
sample_img = plt.imread("./banana.jpeg")
 
# Display information about the original image
print(f"Original image shape: {sample_img.shape}")
print(f"Original image pixel range: ({sample_img.min()}, {sample_img.max()})")
 
# Display the original image using matplotlib
plt.imshow(sample_img)
plt.show()
 
# Preprocess the image (assumed to be a function named preprocess)
preprocess_img = preprocess(sample_img)
 
# Display information about the preprocessed image
print(f"Preprocessed image shape: {preprocess_img.shape}")
print(
    f"Preprocessed image pixel range: ({preprocess_img.numpy().min()},",
    f"{preprocess_img.numpy().max()})",
)
 
# Expand dimensions and cast the image for batching
batched_img = tf.expand_dims(preprocess_img, axis=0)
batched_img = tf.cast(batched_img, tf.float32)
print(f"Batched image shape: {batched_img.shape}")
 
# Assuming 'model' is a pre-trained TensorFlow model
# Run the model inference on the batched image
model_outputs = model(batched_img)
 
# Display information about the model's output
print(f"Model output shape: {model_outputs.shape}")
print(f"Predicted class: {postprocess(model_outputs)}")

Preprocessed image shape: (224, 224, 3)
Preprocessed image pixel range: (-1.0, 1.0)
Batched image shape: (1, 224, 224, 3)
Model output shape: (1, 1000)
Predicted class: [b'banana']

model_dir = "./model"
model_version = 1
model_export_path = f"{model_dir}/{model_version}"
 
tf.saved_model.save(
    model,
    export_dir=model_export_path,
)
 
print(f"SavedModel files: {os.listdir(model_export_path)}")

WARNING:absl:Found untraced functions such as _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op, _jit_compiled_convolution_op while saving (showing 5 of 28). These functions will not be directly callable after loading.
> INFO:tensorflow:Assets written to: ./model/1/assets
> INFO:tensorflow:Assets written to: ./model/1/assets
> SavedModel files: ['fingerprint.pb', 'variables', 'saved_model.pb', 'assets']

!saved_model_cli show --dir {model_export_path} --tag_set serve --signature_def serving_default

The given SavedModel SignatureDef contains the following input(s):
  inputs['input_1'] tensor_info:
      dtype: DT_FLOAT
      shape: (-1, 224, 224, 3)
      name: serving_default_input_1:0
The given SavedModel SignatureDef contains the following output(s):
  outputs['predictions'] tensor_info:
      dtype: DT_FLOAT
      shape: (-1, 1000)
      name: StatefulPartitionedCall:0
Method name is: tensorflow/serving/predict

wget 'http://storage.googleapis.com/tensorflow-serving-apt/pool/tensorflow-model-server-universal-2.8.0/t/tensorflow-model-server-universal/tensorflow-model-server-universal_2.8.0_all.deb'
dpkg -i tensorflow-model-server-universal_2.8.0_all.deb

docker run -p 8501:8501 --name=tf_serving_container --mount type=bind,source=/path/to/model/directory,target=/models/model_name -e MODEL_NAME=model_name -t tensorflow/serving

docker run --runtime=nvidia -p 8501:8501 \
 --mount type=bind,source=/tmp/tfserving/serving/tensorflow_serving/servables/tensorflow/testdata/saved_model_half_plus_two_gpu,target=/models/half_plus_two \
 -e MODEL_NAME=half_plus_two -t tensorflow/serving:latest-gpu &

Exporting HTTP/REST API at:localhost:8501... 
TARGET_LOG: Entering the event loop

model_configs_list:{
    config:{
        name: "amd",
        base: "/models/amd",
        platform: "tensorflow"
    },
    config: {
        name: "resnet",
        base: "models/resnet",
        platform: "tensorflow"
    }
}

curl -d '{"instances": [input_data]}' -H "Content-Type: application/json" -X POST http://localhost:8501/v1/models/model_1:predict

import json
import requests
import numpy as np
 
# Convert the batched image data to a JSON format
data = json.dumps(
    {"signature_name": "serving_default", "instances": batched_img.numpy().tolist()}
)
 
# URL for making a POST request to a TensorFlow Serving model
url = "http://localhost:8501/v1/models/model:predict"
 
# Define a function to send a REST request for prediction
def predict_rest(json_data, url):
    # Send a POST request to the specified URL with JSON data
    json_response = requests.post(url, data=json_data)
    
    # Parse the JSON response
    response = json.loads(json_response.text)
    
    # Extract the prediction outputs from the response and convert to a NumPy array
    rest_outputs = np.array(response["predictions"])
    
    return rest_outputs
 
# Call the function to get prediction outputs using REST API
rest_outputs = predict_rest(data, url)
 
# Assuming postprocess() is a function that processes prediction outputs
# and returns the predicted class
predicted_class = postprocess(rest_outputs)
 
# Print the shape of the REST output and the predicted class
print(f"REST output shape: {rest_outputs.shape}")
print(f"Predicted class: {predicted_class}")
 

REST output shape: (1, 1000)
Predicted class: [b'banana']