TensorFlow 2.0入门

$ pip install -U --pre tensorflow

$ pip install tfds-nightly

import tensorflow_datasets as tfds
print(tfds.list_builders())

import tensorflow_datasets as tfds
 
SPLIT_WEIGHTS = (8, 1, 1)
splits = tfds.Split.TRAIN.subsplit(weighted=SPLIT_WEIGHTS)
(raw_train, raw_validation, raw_test), metadata = tfds.load(name="tf_flowers",
                                                            with_info=True,
                                                            split=list(splits),
# specifying batch_size=-1 will load full dataset in the memory
#                                                             batch_size=-1,
# as_supervised: `bool`, if `True`, the returned `tf.data.Dataset`
# will have a 2-tuple structure `(input, label)`                                                            
                                                            as_supervised=True)

def format_example(image, label):
    image = tf.cast(image, tf.float32)
    # Normalize the pixel values
    image = image / 255.0
    # Resize the image
    image = tf.image.resize(image, (IMG_SIZE, IMG_SIZE))
    return image, label
 
train = raw_train.map(format_example)
validation = raw_validation.map(format_example)
test = raw_test.map(format_example)

ds = image_label_ds.apply( tf.data.experimental.shuffle_and_repeat(buffer_size=image_count))
ds = ds.batch(BATCH_SIZE)
ds = ds.prefetch(buffer_size=AUTOTUNE)

def augment_data(image, label):
  print("Augment data called!")
  image = tf.image.random_flip_left_right(image)
  image = tf.image.random_contrast(image, lower=0.0, upper=1.0)
  # Add more augmentation of your choice
  return image, label
 
train = train.map(augment_data)

plt.figure(figsize=(12,12))
 
for batch in train.take(1):
    for i in range(9):
        image, label = batch[0][i], batch[1][i]
        plt.subplot(3, 3, i+1)
        plt.imshow(image.numpy())
        plt.title(get_label_name(label.numpy()))
        plt.grid(False)    
# OR
for batch in tfds.as_numpy(train):
    for i in range(9):
        image, label = batch[0][i], batch[1][i]
        plt.subplot(3, 3, i+1)
        plt.imshow(image)
        plt.title(get_label_name(label))
        plt.grid(False)
    # We need to break the loop else the outer loop
    # will loop over all the batches in the training set
    break

from tensorflow import keras
 
# Creating a simple CNN model in keras using functional API
def create_model():
    img_inputs = keras.Input(shape=IMG_SHAPE)
    conv_1 = keras.layers.Conv2D(32, (3, 3), activation='relu')(img_inputs)
    maxpool_1 = keras.layers.MaxPooling2D((2, 2))(conv_1)
    conv_2 = keras.layers.Conv2D(64, (3, 3), activation='relu')(maxpool_1)
    maxpool_2 = keras.layers.MaxPooling2D((2, 2))(conv_2)
    conv_3 = keras.layers.Conv2D(64, (3, 3), activation='relu')(maxpool_2)
    flatten = keras.layers.Flatten()(conv_3)
    dense_1 = keras.layers.Dense(64, activation='relu')(flatten)
    output = keras.layers.Dense(metadata.features['label'].num_classes, activation='softmax')(dense_1)
 
    model = keras.Model(inputs=img_inputs, outputs=output)
    
    return model

# Calculating number of images in train, val and test sets
num_train, num_val, num_test = (
metadata.splits['train'].num_examples * weight/10
for weight in SPLIT_WEIGHTS
)
steps_per_epoch = round(num_train)//BATCH_SIZE
validation_steps = round(num_val)//BATCH_SIZE

def train_model(model):
    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
 
    # Creating Keras callbacks
    tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
    model_checkpoint_callback = keras.callbacks.ModelCheckpoint(
        'training_checkpoints/weights.{epoch:02d}-{val_loss:.2f}.hdf5', period=5)
    os.makedirs('training_checkpoints/', exist_ok=True)
    early_stopping_checkpoint = keras.callbacks.EarlyStopping(patience=5)
 
    history = model.fit(train.repeat(),
              epochs=epochs,
              steps_per_epoch=steps_per_epoch,
              validation_data=validation.repeat(),
              validation_steps=validation_steps,
              callbacks=[tensorboard_callback,
                         model_checkpoint_callback,
                         early_stopping_checkpoint])
    
return history

%load_ext tensorboard.notebook
%tensorboard --logdir logs/

from tensorflow import keras


# Create the base model from the pre-trained model MobileNet V2
base_model = keras.applications.InceptionV3(input_shape=IMG_SHAPE,
# We cannot use the top classification layer of the pre-trained model as it contains 1000 classes.
# It also restricts our input dimensions to that which this model is trained on (default: 299x299)
                                               include_top=False,
                                               weights='imagenet')

def build_model():
    
    # Using Sequential API to stack up the layers
    model = keras.Sequential([
        base_model,
        keras.layers.GlobalAveragePooling2D(),
        keras.layers.Dense(metadata.features['label'].num_classes,
                           activation='softmax')
    ])
    
    # Compile the model to configure training parameters
    model.compile(optimizer='adam',
                  loss='sparse_categorical_crossentropy',
                  metrics=['accuracy'])
    return model
 
inception_model = build_model()

# Un-freeze the top layers of the model
base_model.trainable = True
# Let's take a look to see how many layers are in the base model
print("Number of layers in the base model: ", len(base_model.layers))
 
# Fine tune from this layer onwards
fine_tune_at = 249
 
# Freeze all the layers before the `fine_tune_at` layer
for layer in base_model.layers[:fine_tune_at]:
    layer.trainable =  False
    
# Compile the model using a much lower learning rate.
inception_model.compile(optimizer = tf.keras.optimizers.RMSprop(lr=0.0001),
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
 
history_fine = inception_model.fit(train.repeat(),
                                   steps_per_epoch = steps_per_epoch,
                                   epochs = finetune_epochs,
                                   initial_epoch = initial_epoch,
                                   validation_data = validation.repeat(),
                                   validation_steps = validation_steps)

$ echo "deb [arch=amd64] http://storage.googleapis.com/tensorflow-serving-apt stable tensorflow-model-server tensorflow-model-server-universal" | sudo tee /etc/apt/sources.list.d/tensorflow-serving.list && \
$ curl https://storage.googleapis.com/tensorflow-serving-apt/tensorflow-serving.release.pub.gpg | sudo apt-key add -

$ apt-get update && apt-get install tensorflow-model-server

from tensorflow import keras
 
# '/1' specifies the version of a model, or "servable" we want to export
path_to_saved_model = 'SavedModel/inceptionv3_128_tf_flowers/1'
 
# Saving the keras model in SavedModel format
keras.experimental.export_saved_model(inception_model, path_to_saved_model)
 
# Load the saved keras model back
restored_saved_model = keras.experimental.load_from_saved_model(path_to_saved_model)

$ tensorflow_model_server --model_base_path=/home/ubuntu/Desktop/Medium/TF2.0/SavedModel/inceptionv3_128_tf_flowers/ --rest_api_port=9000 --model_name=FlowerClassifier

Failed to start server. Error: Invalid argument: Expected model ImageClassifier to have an absolute path or URI; got base_path()=./inceptionv3_128_tf_flowers

http://host:port/v1/models/${MODEL_NAME}[/versions/${MODEL_VERSION}]:predict

import json, requests
from tensorflow.keras.preprocessing.image import img_to_array, load_img
import numpy as np
 
image_path = 'sunflower.jpg'
# Loading and pre-processing our input image
img = image.img_to_array(image.load_img(image_path, target_size=(128, 128))) / 255.
img = np.expand_dims(img, axis=0)
payload = {"instances": img.tolist()}
 
# sending post request to TensorFlow Serving server
json_response = requests.post('http://localhost:9000/v1/models/FlowerClassifier:predict', json=payload)
pred = json.loads(json_response.content.decode('utf-8'))
 
# Decoding the response using decode_predictions() helper function
# You can pass "k=5" to get top 5 predicitons
get_top_k_predictions(pred, k=3)

Top 3 predictions:
[('sunflowers', 0.978735), ('tulips', 0.0145516), ('roses', 0.00366251)]