reponame
stringclasses 2
values | filepath
stringclasses 18
values | content
stringclasses 18
values |
|---|---|---|
sayakpaul/CI-CD-for-Model-Training | cloud_build_tfx.ipynb | from google.colab import auth
auth.authenticate_user()GOOGLE_CLOUD_PROJECT = "fast-ai-exploration"
GOOGLE_CLOUD_REGION = "us-central1"
GCS_BUCKET_NAME = "vertex-tfx-mlops"
PIPELINE_NAME = "penguin-vertex-training"
DATA_ROOT = "gs://{}/data/{}".format(GCS_BUCKET_NAME, PIPELINE_NAME)
MODULE_ROOT = "gs://{}/pipeline_module/{}".format(GCS_BUCKET_NAME, PIPELINE_NAME)
if not (GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_REGION and GCS_BUCKET_NAME):
from absl import logging
logging.error("Please set all required parameters.")_trainer_module_file = 'penguin_trainer.py'%%writefile {_trainer_module_file}
# Copied from https://www.tensorflow.org/tfx/tutorials/tfx/penguin_simple and
# slightly modified run_fn() to add distribution_strategy.
from typing import List
from absl import logging
import tensorflow as tf
from tensorflow import keras
from tensorflow_metadata.proto.v0 import schema_pb2
from tensorflow_transform.tf_metadata import schema_utils
from tfx import v1 as tfx
from tfx_bsl.public import tfxio
_FEATURE_KEYS = [
"culmen_length_mm",
"culmen_depth_mm",
"flipper_length_mm",
"body_mass_g",
]
_LABEL_KEY = "species"
_TRAIN_BATCH_SIZE = 20
_EVAL_BATCH_SIZE = 10
# Since we're not generating or creating a schema, we will instead create
# a feature spec. Since there are a fairly small number of features this is
# manageable for this dataset.
_FEATURE_SPEC = {
**{
feature: tf.io.FixedLenFeature(shape=[1], dtype=tf.float32)
for feature in _FEATURE_KEYS
},
_LABEL_KEY: tf.io.FixedLenFeature(shape=[1], dtype=tf.int64),
}
def _input_fn(
file_pattern: List[str],
data_accessor: tfx.components.DataAccessor,
schema: schema_pb2.Schema,
batch_size: int,
) -> tf.data.Dataset:
"""Generates features and label for training.
Args:
file_pattern: List of paths or patterns of input tfrecord files.
data_accessor: DataAccessor for converting input to RecordBatch.
schema: schema of the input data.
batch_size: representing the number of consecutive elements of returned
dataset to combine in a single batch
Returns:
A dataset that contains (features, indices) tuple where features is a
dictionary of Tensors, and indices is a single Tensor of label indices.
"""
return data_accessor.tf_dataset_factory(
file_pattern,
tfxio.TensorFlowDatasetOptions(batch_size=batch_size, label_key=_LABEL_KEY),
schema=schema,
).repeat()
def _make_keras_model(learning_rate: float) -> tf.keras.Model:
"""Creates a DNN Keras model for classifying penguin data.
Returns:
A Keras Model.
"""
# The model below is built with Functional API, please refer to
# https://www.tensorflow.org/guide/keras/overview for all API options.
inputs = [keras.layers.Input(shape=(1,), name=f) for f in _FEATURE_KEYS]
d = keras.layers.concatenate(inputs)
for _ in range(2):
d = keras.layers.Dense(8, activation="relu")(d)
outputs = keras.layers.Dense(3)(d)
model = keras.Model(inputs=inputs, outputs=outputs)
optimizer = keras.optimizers.Adam(learning_rate)
model.compile(
optimizer=optimizer,
loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=[keras.metrics.SparseCategoricalAccuracy()],
)
model.summary(print_fn=logging.info)
return model
# NEW: Read `use_gpu` from the custom_config of the Trainer.
# if it uses GPU, enable MirroredStrategy.
def _get_distribution_strategy(fn_args: tfx.components.FnArgs):
if fn_args.custom_config.get("use_gpu", False):
logging.info("Using MirroredStrategy with one GPU.")
return tf.distribute.MirroredStrategy(devices=["device:GPU:0"])
return None
# TFX Trainer will call this function.
def run_fn(fn_args: tfx.components.FnArgs):
"""Train the model based on given args.
Args:
fn_args: Holds args used to train the model as name/value pairs.
"""
# This schema is usually either an output of SchemaGen or a manually-curated
# version provided by pipeline author. A schema can also derived from TFT
# graph if a Transform component is used. In the case when either is missing,
# `schema_from_feature_spec` could be used to generate schema from very simple
# feature_spec, but the schema returned would be very primitive.
schema = schema_utils.schema_from_feature_spec(_FEATURE_SPEC)
hyperparameters = fn_args.hyperparameters
logging.info("Hyperparameters:")
logging.info(hyperparameters)
train_dataset = _input_fn(
fn_args.train_files, fn_args.data_accessor, schema, batch_size=_TRAIN_BATCH_SIZE
)
eval_dataset = _input_fn(
fn_args.eval_files, fn_args.data_accessor, schema, batch_size=_EVAL_BATCH_SIZE
)
# NEW: If we have a distribution strategy, build a model in a strategy scope.
strategy = _get_distribution_strategy(fn_args)
if strategy is None:
model = _make_keras_model(hyperparameters["learning_rate"])
else:
with strategy.scope():
model = _make_keras_model(hyperparameters["learning_rate"])
model.fit(
train_dataset,
steps_per_epoch=fn_args.train_steps,
validation_data=eval_dataset,
validation_steps=fn_args.eval_steps,
epochs=hyperparameters["num_epochs"],
)
# The result of the training should be saved in `fn_args.serving_model_dir`
# directory.
model.save(fn_args.serving_model_dir, save_format="tf")REPO_URL = "https://github.com/sayakpaul/CI-CD-for-Model-Training"
BRANCH = "dev"
PIPELINE_ROOT = "gs://{}/pipeline_root/{}".format(GCS_BUCKET_NAME, PIPELINE_NAME)
SERVING_MODEL_DIR = "gs://{}/serving_model/{}".format(GCS_BUCKET_NAME, PIPELINE_NAME)
VERSION = "1.0.0"
CICD_IMAGE_URI = f"gcr.io/tfx-oss-public/tfx:{VERSION}"
TFX_IMAGE_URI = f"gcr.io/{GOOGLE_CLOUD_PROJECT}/{PIPELINE_NAME}:{VERSION}"SUBSTITUTIONS=f"""\
_REPO_URL='{REPO_URL}',\
_BRANCH={BRANCH},\
_PROJECT={GOOGLE_CLOUD_PROJECT},\
_REGION={GOOGLE_CLOUD_REGION},\
_PIPELINE_NAME={PIPELINE_NAME},\
_PIPELINE_ROOT={PIPELINE_ROOT},\
_MODULE_ROOT={MODULE_ROOT},\
_DATA_ROOT={DATA_ROOT},\
_SERVING_MODEL_DIR={SERVING_MODEL_DIR},\
_CICD_IMAGE_URI={CICD_IMAGE_URI},\
_TFX_IMAGE_URI={TFX_IMAGE_URI}
"""
!echo $SUBSTITUTIONS |
sayakpaul/CI-CD-for-Model-Training | cloud_function_trigger.ipynb | from google.colab import auth
auth.authenticate_user()GOOGLE_CLOUD_PROJECT = "fast-ai-exploration"
GOOGLE_CLOUD_REGION = "us-central1"
GCS_BUCKET_NAME = "vertex-tfx-mlops"
PIPELINE_NAME = "penguin-vertex-training"
PIPELINE_ROOT = "gs://{}/pipeline_root/{}".format(GCS_BUCKET_NAME, PIPELINE_NAME)
PIPELINE_LOCATION = f"{PIPELINE_ROOT}/{PIPELINE_NAME}.json"
PUBSUB_TOPIC = f"trigger-{PIPELINE_NAME}"
DATA_ROOT = "gs://{}/data/{}".format(GCS_BUCKET_NAME, PIPELINE_NAME)
MODULE_ROOT = "gs://{}/pipeline_module/{}".format(GCS_BUCKET_NAME, PIPELINE_NAME)
if not (GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_REGION and GCS_BUCKET_NAME):
from absl import logging
logging.error("Please set all required parameters.")ENV_VARS=f"""\
PROJECT={GOOGLE_CLOUD_PROJECT},\
REGION={GOOGLE_CLOUD_REGION},\
GCS_PIPELINE_FILE_LOCATION={PIPELINE_LOCATION}
"""
!echo {ENV_VARS}BUCKET = f'gs://{GCS_BUCKET_NAME}'
CLOUD_FUNCTION_NAME = f'trigger-{PIPELINE_NAME}-fn'
!gcloud functions deploy {CLOUD_FUNCTION_NAME} \
--region={GOOGLE_CLOUD_REGION} \
--trigger-topic={PUBSUB_TOPIC} \
--runtime=python37 \
--source=cloud_function\
--entry-point=trigger_pipeline\
--stage-bucket={BUCKET}\
--update-env-vars={ENV_VARS}
# `trigger_pipeline` is the name of the function inside
# `cloud_function/main.py`import IPython
cloud_fn_url = f"https://console.cloud.google.com/functions/details/{GOOGLE_CLOUD_REGION}/{CLOUD_FUNCTION_NAME}"
html = (
f'See the Cloud Function details <a href="{cloud_fn_url}" target="_blank">here</a>.'
)
IPython.display.display(IPython.display.HTML(html))from google.cloud import pubsub
import json
publish_client = pubsub.PublisherClient()
topic = f"projects/{GOOGLE_CLOUD_PROJECT}/topics/{PUBSUB_TOPIC}"
data = {"num_epochs": 3, "learning_rate": 1e-2}
message = json.dumps(data)
_ = publish_client.publish(topic, message.encode()) |
sayakpaul/CI-CD-for-Model-Training | cloud_scheduler_trigger.ipynb | # only need if you are using Colab
from google.colab import auth
auth.authenticate_user()GOOGLE_CLOUD_PROJECT = "gcp-ml-172005"
GOOGLE_CLOUD_REGION = "us-central1"
PIPELINE_NAME = "penguin-vertex-training"
PUBSUB_TOPIC = f"trigger-{PIPELINE_NAME}"
SCHEDULER_JOB_NAME = "MLOpsJob"import json
data = '{"num_epochs": "3", "learning_rate": "1e-2"}'
data = json.dumps(data)import json
from google.cloud import scheduler_v1
from google.cloud.scheduler_v1.types.target import PubsubTarget
from google.cloud.scheduler_v1.types.job import Job
from google.cloud.scheduler_v1.types.cloudscheduler import CreateJobRequest
client = scheduler_v1.CloudSchedulerClient.from_service_account_json(
r"./gcp-ml-172005-528977a75f85.json")parent = client.common_location_path(GOOGLE_CLOUD_PROJECT, GOOGLE_CLOUD_REGION)
data = {"num_epochs": "3", "learning_rate": "1e-2"}
data = json.dumps(data).encode('utf-8')
pubsub_target = PubsubTarget(
topic_name=f"projects/{GOOGLE_CLOUD_PROJECT}/topics/{PUBSUB_TOPIC}",
data=data)
job = Job(name=f"projects/{GOOGLE_CLOUD_PROJECT}/locations/{GOOGLE_CLOUD_REGION}/jobs/traing_for_model",
pubsub_target=pubsub_target,
schedule="*/3 * * * *")
req = CreateJobRequest(parent=parent, job=job)result_job = client.create_job(req)result_job |
sayakpaul/CI-CD-for-Model-Training | build/compile_pipeline.py | import argparse
from absl import logging
from create_pipeline import create_pipeline
from tfx.orchestration import data_types
from tfx.orchestration.kubeflow.v2 import kubeflow_v2_dag_runner
import os
import sys
SCRIPT_DIR = os.path.dirname(
os.path.realpath(os.path.join(os.getcwd(), os.path.expanduser(__file__)))
)
sys.path.append(os.path.normpath(os.path.join(SCRIPT_DIR, "..")))
from utils import config
def get_args():
parser = argparse.ArgumentParser()
parser.add_argument(
"--use-gpu",
type=str,
required=False,
default="False"
)
return parser.parse_args()
def compile_pipeline(args):
pipeline_definition_file = config.PIPELINE_NAME + ".json"
runner = kubeflow_v2_dag_runner.KubeflowV2DagRunner(
config=kubeflow_v2_dag_runner.KubeflowV2DagRunnerConfig(
default_image=config.TFX_IMAGE_URI
),
output_filename=pipeline_definition_file,
)
use_gpu = True if args.use_gpu == "True" else False
return runner.run(
create_pipeline(
num_epochs=data_types.RuntimeParameter(name="num_epochs", ptype=int),
learning_rate=data_types.RuntimeParameter(name="learning_rate", ptype=float),
use_gpu=use_gpu,
),
write_out=True,
)
def main():
args = get_args()
result = compile_pipeline(args)
logging.info(result)
if __name__ == "__main__":
main()
|
sayakpaul/CI-CD-for-Model-Training | build/create_pipeline.py | from tfx.orchestration import data_types
from tfx import v1 as tfx
import os
import sys
SCRIPT_DIR = os.path.dirname(
os.path.realpath(os.path.join(os.getcwd(), os.path.expanduser(__file__)))
)
sys.path.append(os.path.normpath(os.path.join(SCRIPT_DIR, "..")))
from utils import config, custom_components
def create_pipeline(
num_epochs: data_types.RuntimeParameter,
learning_rate: data_types.RuntimeParameter,
use_gpu: bool,
) -> tfx.dsl.Pipeline:
"""Implements the penguin pipeline with TFX."""
# Brings data into the pipeline or otherwise joins/converts training data.
example_gen = tfx.components.CsvExampleGen(input_base=config.DATA_ROOT)
# Generate hyperparameters.
hyperparams_gen = custom_components.hyperparameters_gen(
num_epochs=num_epochs,
learning_rate=learning_rate
).with_id("HyperparamsGen")
# NEW: Configuration for Vertex AI Training.
# This dictionary will be passed as `CustomJobSpec`.
vertex_job_spec = {
"project": config.GCP_PROJECT,
"worker_pool_specs": [
{
"machine_spec": {
"machine_type": "n1-standard-4",
},
"replica_count": 1,
"container_spec": {
"image_uri": "gcr.io/tfx-oss-public/tfx:{}".format(tfx.__version__),
},
}
],
}
if use_gpu:
# See https://cloud.google.com/vertex-ai/docs/reference/rest/v1/MachineSpec#acceleratortype
# for available machine types.
vertex_job_spec["worker_pool_specs"][0]["machine_spec"].update(
{"accelerator_type": "NVIDIA_TESLA_K80", "accelerator_count": 1}
)
# Trains a model using Vertex AI Training.
# NEW: We need to specify a Trainer for GCP with related configs.
trainer = tfx.extensions.google_cloud_ai_platform.Trainer(
module_file=config.MODULE_FILE,
examples=example_gen.outputs["examples"],
train_args=tfx.proto.TrainArgs(num_steps=100),
eval_args=tfx.proto.EvalArgs(num_steps=5),
hyperparameters=hyperparams_gen.outputs["hyperparameters"],
custom_config={
tfx.extensions.google_cloud_ai_platform.ENABLE_UCAIP_KEY: True,
tfx.extensions.google_cloud_ai_platform.UCAIP_REGION_KEY: config.GCP_REGION,
tfx.extensions.google_cloud_ai_platform.TRAINING_ARGS_KEY: vertex_job_spec,
"use_gpu": use_gpu,
},
)
# Pushes the model to a filesystem destination.
pusher = tfx.components.Pusher(
model=trainer.outputs["model"],
push_destination=tfx.proto.PushDestination(
filesystem=tfx.proto.PushDestination.Filesystem(
base_directory=config.SERVING_MODEL_DIR
)
),
)
components = [
example_gen,
hyperparams_gen,
trainer,
pusher,
]
return tfx.dsl.Pipeline(
pipeline_name=config.PIPELINE_NAME, pipeline_root=config.PIPELINE_ROOT, components=components
)
|
sayakpaul/CI-CD-for-Model-Training | build/penguin_trainer.py | # Copied from https://www.tensorflow.org/tfx/tutorials/tfx/penguin_simple and
# slightly modified run_fn() to add distribution_strategy.
from typing import List
from absl import logging
import tensorflow as tf
from tensorflow import keras
from tensorflow_metadata.proto.v0 import schema_pb2
from tensorflow_transform.tf_metadata import schema_utils
from tfx import v1 as tfx
from tfx_bsl.public import tfxio
_FEATURE_KEYS = [
"culmen_length_mm",
"culmen_depth_mm",
"flipper_length_mm",
"body_mass_g",
]
_LABEL_KEY = "species"
_TRAIN_BATCH_SIZE = 20
_EVAL_BATCH_SIZE = 10
# Since we're not generating or creating a schema, we will instead create
# a feature spec. Since there are a fairly small number of features this is
# manageable for this dataset.
_FEATURE_SPEC = {
**{
feature: tf.io.FixedLenFeature(shape=[1], dtype=tf.float32)
for feature in _FEATURE_KEYS
},
_LABEL_KEY: tf.io.FixedLenFeature(shape=[1], dtype=tf.int64),
}
def _input_fn(
file_pattern: List[str],
data_accessor: tfx.components.DataAccessor,
schema: schema_pb2.Schema,
batch_size: int,
) -> tf.data.Dataset:
"""Generates features and label for training.
Args:
file_pattern: List of paths or patterns of input tfrecord files.
data_accessor: DataAccessor for converting input to RecordBatch.
schema: schema of the input data.
batch_size: representing the number of consecutive elements of returned
dataset to combine in a single batch
Returns:
A dataset that contains (features, indices) tuple where features is a
dictionary of Tensors, and indices is a single Tensor of label indices.
"""
return data_accessor.tf_dataset_factory(
file_pattern,
tfxio.TensorFlowDatasetOptions(batch_size=batch_size, label_key=_LABEL_KEY),
schema=schema
).repeat()
def _make_keras_model(learning_rate: float) -> tf.keras.Model:
"""Creates a DNN Keras model for classifying penguin data.
Returns:
A Keras Model.
"""
# The model below is built with Functional API, please refer to
# https://www.tensorflow.org/guide/keras/overview for all API options.
inputs = [keras.layers.Input(shape=(1,), name=f) for f in _FEATURE_KEYS]
d = keras.layers.concatenate(inputs)
for _ in range(2):
d = keras.layers.Dense(8, activation="relu")(d)
outputs = keras.layers.Dense(3)(d)
model = keras.Model(inputs=inputs, outputs=outputs)
optimizer = keras.optimizers.Adam(learning_rate)
model.compile(
optimizer=optimizer,
loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
metrics=[keras.metrics.SparseCategoricalAccuracy()],
)
model.summary(print_fn=logging.info)
return model
# NEW: Read `use_gpu` from the custom_config of the Trainer.
# if it uses GPU, enable MirroredStrategy.
def _get_distribution_strategy(fn_args: tfx.components.FnArgs):
if fn_args.custom_config.get("use_gpu", False):
logging.info("Using MirroredStrategy with one GPU.")
return tf.distribute.MirroredStrategy(devices=["device:GPU:0"])
return None
# TFX Trainer will call this function.
def run_fn(fn_args: tfx.components.FnArgs):
"""Train the model based on given args.
Args:
fn_args: Holds args used to train the model as name/value pairs.
"""
# This schema is usually either an output of SchemaGen or a manually-curated
# version provided by pipeline author. A schema can also derived from TFT
# graph if a Transform component is used. In the case when either is missing,
# `schema_from_feature_spec` could be used to generate schema from very simple
# feature_spec, but the schema returned would be very primitive.
schema = schema_utils.schema_from_feature_spec(_FEATURE_SPEC)
hyperparameters = fn_args.hyperparameters
logging.info("Hyperparameters:")
logging.info(hyperparameters)
train_dataset = _input_fn(
fn_args.train_files, fn_args.data_accessor, schema, batch_size=_TRAIN_BATCH_SIZE
)
eval_dataset = _input_fn(
fn_args.eval_files, fn_args.data_accessor, schema, batch_size=_EVAL_BATCH_SIZE
)
# NEW: If we have a distribution strategy, build a model in a strategy scope.
strategy = _get_distribution_strategy(fn_args)
if strategy is None:
model = _make_keras_model(hyperparameters["learning_rate"])
else:
with strategy.scope():
model = _make_keras_model(hyperparameters["learning_rate"])
model.fit(
train_dataset,
steps_per_epoch=fn_args.train_steps,
validation_data=eval_dataset,
validation_steps=fn_args.eval_steps,
epochs=hyperparameters["num_epochs"],
)
# The result of the training should be saved in `fn_args.serving_model_dir`
# directory.
model.save(fn_args.serving_model_dir, save_format="tf")
|
sayakpaul/CI-CD-for-Model-Training | cloud_function/main.py | # Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Cloud Function to be triggered by Pub/Sub."""
import os
import json
import logging
import base64
from kfp.v2.google.client import AIPlatformClient
from google.cloud import storage
def trigger_pipeline(event, context):
# Parse the environment variables.
project = os.getenv("PROJECT")
region = os.getenv("REGION")
gcs_pipeline_file_location = os.getenv("GCS_PIPELINE_FILE_LOCATION")
if not project:
raise ValueError("Environment variable GCP_PROJECT is not set.")
if not region:
raise ValueError("Environment variable GCP_REGION is not set.")
if not gcs_pipeline_file_location:
raise ValueError("Environment variable GCS_PIPELINE_FILE_LOCATION is not set.")
# Check if the pipeline file exists in the provided GCS Bucket.
storage_client = storage.Client()
if not gcs_pipeline_file_location:
raise ValueError("Environment variable GCS_PIPELINE_FILE_LOCATION is not set.")
path_parts = gcs_pipeline_file_location.replace("gs://", "").split("/")
bucket_name = path_parts[0]
blob_name = "/".join(path_parts[1:])
bucket = storage_client.bucket(bucket_name)
blob = storage.Blob(bucket=bucket, name=blob_name)
if not blob.exists(storage_client):
raise ValueError(f"{gcs_pipeline_file_location} does not exist.")
# Parse the data from the Pub/Sub trigger message.
data = base64.b64decode(event["data"]).decode("utf-8")
logging.info(f"Event data: {data}")
parameter_values = json.loads(data)
# Initialize Vertex AI API client and submit for pipeline execution.
api_client = AIPlatformClient(project_id=project, region=region)
response = api_client.create_run_from_job_spec(
job_spec_path=gcs_pipeline_file_location,
parameter_values=parameter_values,
enable_caching=True,
)
logging.info(response)
|
sayakpaul/CI-CD-for-Model-Training | utils/config.py | import os
# GCP
GCP_PROJECT = os.getenv("PROJECT")
GCP_REGION = os.getenv("REGION")
# Data
DATA_ROOT = os.getenv("DATA_ROOT")
# Training and serving
TFX_IMAGE_URI = os.getenv("TFX_IMAGE_URI")
MODULE_ROOT = os.getenv("MODULE_ROOT")
MODULE_FILE = os.path.join(MODULE_ROOT, "penguin_trainer.py")
SERVING_MODEL_DIR = os.getenv("MODULE_ROOT")
# Pipeline
PIPELINE_NAME = os.getenv("PIPELINE_NAME")
PIPELINE_ROOT = os.getenv("SERVING_MODEL_DIR")
|
sayakpaul/CI-CD-for-Model-Training | utils/custom_components.py | """
Taken from:
* https://github.com/GoogleCloudPlatform/mlops-with-vertex-ai/blob/main/src/tfx_pipelines/components.py#L51
"""
from tfx.dsl.component.experimental.decorators import component
from tfx.dsl.component.experimental.annotations import (
InputArtifact,
OutputArtifact,
Parameter,
)
from tfx.types.standard_artifacts import HyperParameters
from tfx.types import artifact_utils
from tfx.utils import io_utils
import logging
import json
import os
@component
def hyperparameters_gen(
num_epochs: Parameter[int],
learning_rate: Parameter[float],
hyperparameters: OutputArtifact[HyperParameters],
):
hp_dict = dict()
hp_dict["num_epochs"] = num_epochs
hp_dict["learning_rate"] = learning_rate
logging.info(f"Hyperparameters: {hp_dict}")
hyperparams_uri = os.path.join(
artifact_utils.get_single_uri([hyperparameters]), "hyperparameters.json"
)
io_utils.write_string_file(hyperparams_uri, json.dumps(hp_dict))
logging.info(f"Hyperparameters are written to: {hyperparams_uri}")
|
sayakpaul/Dual-Deployments-on-Vertex-AI | custom_components/firebase_publisher.py | """
Custom TFX component for Firebase upload.
Author: Chansung Park
"""
from tfx import types
from tfx.dsl.component.experimental.decorators import component
from tfx.dsl.component.experimental.annotations import Parameter
from tfx import v1 as tfx
from absl import logging
import firebase_admin
from firebase_admin import ml
from firebase_admin import storage
from firebase_admin import credentials
from google.cloud import storage as gcs_storage
@component
def FirebasePublisher(
pushed_model: tfx.dsl.components.InputArtifact[
tfx.types.standard_artifacts.PushedModel
],
credential_uri: Parameter[str],
firebase_dest_gcs_bucket: Parameter[str],
model_display_name: Parameter[str],
model_tag: Parameter[str],
) -> tfx.dsl.components.OutputDict(result=str):
"""
publish trained tflite model to Firebase ML, this component assumes that
trained model and Firebase credential files are stored in GCS locations.
Args:
pushed_model: The URI of pushed model obtained from previous component (i.e. Pusher)
credential_uri: The URI of Firebase credential. In order to get one, go to Firebase dashboard
and on the Settings page, create a service account and download the service account key file.
Keep this file safe, since it grants administrator access to your project.
firebase_dest_gcs_bucket: GCS bucket where the model is going to be temporarily stored.
In order to create one, go to Firebase dashboard and on the Storage page, enable Cloud Storage.
Take note of your bucket name.
model_display_name: The name to be appeared on Firebase ML dashboard
model_tag: The tage name to be appeared on Firebase ML dashboard
"""
model_uri = f"{pushed_model.uri}/model.tflite"
assert model_uri.split("://")[0] == "gs"
assert credential_uri.split("://")[0] == "gs"
# create gcs client instance
gcs_client = gcs_storage.Client()
# get credential for firebase
credential_gcs_bucket = credential_uri.split("//")[1].split("/")[0]
credential_blob_path = "/".join(credential_uri.split("//")[1].split("/")[1:])
bucket = gcs_client.bucket(credential_gcs_bucket)
blob = bucket.blob(credential_blob_path)
blob.download_to_filename("credential.json")
logging.info(f"download credential.json from {credential_uri} is completed")
# get tflite model file
tflite_gcs_bucket = model_uri.split("//")[1].split("/")[0]
tflite_blob_path = "/".join(model_uri.split("//")[1].split("/")[1:])
bucket = gcs_client.bucket(tflite_gcs_bucket)
blob = bucket.blob(tflite_blob_path)
blob.download_to_filename("model.tflite")
logging.info(f"download model.tflite from {model_uri} is completed")
firebase_admin.initialize_app(
credentials.Certificate("credential.json"),
options={"storageBucket": firebase_dest_gcs_bucket},
)
logging.info("firebase_admin initialize app is completed")
model_list = ml.list_models(list_filter=f"display_name={model_display_name}")
# update
if len(model_list.models) > 0:
# get the first match model
model = model_list.models[0]
source = ml.TFLiteGCSModelSource.from_tflite_model_file("model.tflite")
model.model_format = ml.TFLiteFormat(model_source=source)
updated_model = ml.update_model(model)
ml.publish_model(updated_model.model_id)
logging.info("model exists, so update it in FireBase ML")
return {"result": "model updated"}
# create
else:
# load a tflite file and upload it to Cloud Storage
source = ml.TFLiteGCSModelSource.from_tflite_model_file("model.tflite")
# create the model object
tflite_format = ml.TFLiteFormat(model_source=source)
model = ml.Model(
display_name=model_display_name,
tags=[model_tag],
model_format=tflite_format,
)
# Add the model to your Firebase project and publish it
new_model = ml.create_model(model)
ml.publish_model(new_model.model_id)
logging.info("model doesn exists, so create one in FireBase ML")
return {"result": "model created"}
|
sayakpaul/Dual-Deployments-on-Vertex-AI | custom_components/flower_densenet_trainer.py | from typing import List
from absl import logging
from tensorflow import keras
from tfx import v1 as tfx
import tensorflow as tf
_IMAGE_FEATURES = {
"image": tf.io.FixedLenFeature([], tf.string),
"class": tf.io.FixedLenFeature([], tf.int64),
"one_hot_class": tf.io.VarLenFeature(tf.float32),
}
_CONCRETE_INPUT = "numpy_inputs"
_INPUT_SHAPE = (224, 224, 3)
_TRAIN_BATCH_SIZE = 64
_EVAL_BATCH_SIZE = 64
_EPOCHS = 2
def _parse_fn(example):
example = tf.io.parse_single_example(example, _IMAGE_FEATURES)
image = tf.image.decode_jpeg(example["image"], channels=3)
class_label = tf.cast(example["class"], tf.int32)
return image, class_label
def _input_fn(file_pattern: List[str], batch_size: int) -> tf.data.Dataset:
"""Generates features and label for training.
Args:
file_pattern: List of paths or patterns of input tfrecord files.
batch_size: representing the number of consecutive elements of returned
dataset to combine in a single batch.
Returns:
A dataset that contains (features, indices) tuple where features is a
dictionary of Tensors, and indices is a single Tensor of label indices.
"""
logging.info(f"Reading data from: {file_pattern}")
tfrecord_filenames = tf.io.gfile.glob(file_pattern[0] + ".gz")
dataset = tf.data.TFRecordDataset(tfrecord_filenames, compression_type="GZIP")
dataset = dataset.map(_parse_fn).batch(batch_size)
return dataset.repeat()
def _make_keras_model() -> tf.keras.Model:
"""Creates a DenseNet121-based model for classifying flowers data.
Returns:
A Keras Model.
"""
inputs = keras.Input(shape=_INPUT_SHAPE)
base_model = keras.applications.DenseNet121(
include_top=False, input_shape=_INPUT_SHAPE, pooling="avg"
)
base_model.trainable = False
x = keras.applications.densenet.preprocess_input(inputs)
x = base_model(
x, training=False
) # Ensures BatchNorm runs in inference model in this model
outputs = keras.layers.Dense(5, activation="softmax")(x)
model = keras.Model(inputs, outputs)
model.compile(
optimizer=keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=[keras.metrics.SparseCategoricalAccuracy()],
)
model.summary(print_fn=logging.info)
return model
def _preprocess(bytes_input):
decoded = tf.io.decode_jpeg(bytes_input, channels=3)
resized = tf.image.resize(decoded, size=(224, 224))
return resized
@tf.function(input_signature=[tf.TensorSpec([None], tf.string)])
def preprocess_fn(bytes_inputs):
decoded_images = tf.map_fn(
_preprocess, bytes_inputs, dtype=tf.float32, back_prop=False
)
return {_CONCRETE_INPUT: decoded_images}
def _model_exporter(model: tf.keras.Model):
m_call = tf.function(model.call).get_concrete_function(
[
tf.TensorSpec(
shape=[None, 224, 224, 3], dtype=tf.float32, name=_CONCRETE_INPUT
)
]
)
@tf.function(input_signature=[tf.TensorSpec([None], tf.string)])
def serving_fn(bytes_inputs):
# This function comes from the Computer Vision book from O'Reilly.
labels = tf.constant(
["daisy", "dandelion", "roses", "sunflowers", "tulips"], dtype=tf.string
)
images = preprocess_fn(bytes_inputs)
probs = m_call(**images)
indices = tf.argmax(probs, axis=1)
pred_source = tf.gather(params=labels, indices=indices)
pred_confidence = tf.reduce_max(probs, axis=1)
return {"label": pred_source, "confidence": pred_confidence}
return serving_fn
# TFX Trainer will call this function.
def run_fn(fn_args: tfx.components.FnArgs):
"""Train the model based on given args.
Args:
fn_args: Holds args used to train the model as name/value pairs.
"""
train_dataset = _input_fn(fn_args.train_files, batch_size=_TRAIN_BATCH_SIZE)
eval_dataset = _input_fn(fn_args.eval_files, batch_size=_EVAL_BATCH_SIZE)
model = _make_keras_model()
model.fit(
train_dataset,
steps_per_epoch=fn_args.train_steps,
validation_data=eval_dataset,
validation_steps=fn_args.eval_steps,
epochs=_EPOCHS,
)
_, acc = model.evaluate(eval_dataset, steps=fn_args.eval_steps)
logging.info(f"Validation accuracy: {round(acc * 100, 2)}%")
# The result of the training should be saved in `fn_args.serving_model_dir`
# directory.
tf.saved_model.save(
model,
fn_args.serving_model_dir,
signatures={"serving_default": _model_exporter(model)},
)
|
sayakpaul/Dual-Deployments-on-Vertex-AI | custom_components/flower_mobilenet_trainer.py | from typing import List
from absl import logging
from tensorflow import keras
from tfx import v1 as tfx
import tensorflow as tf
_IMAGE_FEATURES = {
"image": tf.io.FixedLenFeature([], tf.string),
"class": tf.io.FixedLenFeature([], tf.int64),
"one_hot_class": tf.io.VarLenFeature(tf.float32),
}
_INPUT_SHAPE = (224, 224, 3)
_TRAIN_BATCH_SIZE = 64
_EVAL_BATCH_SIZE = 64
_EPOCHS = 2
def _parse_fn(example):
example = tf.io.parse_single_example(example, _IMAGE_FEATURES)
image = tf.image.decode_jpeg(example["image"], channels=3)
class_label = tf.cast(example["class"], tf.int32)
return image, class_label
def _input_fn(file_pattern: List[str], batch_size: int) -> tf.data.Dataset:
"""Generates features and label for training.
Args:
file_pattern: List of paths or patterns of input tfrecord files.
batch_size: representing the number of consecutive elements of returned
dataset to combine in a single batch.
Returns:
A dataset that contains (features, indices) tuple where features is a
dictionary of Tensors, and indices is a single Tensor of label indices.
"""
logging.info(f"Reading data from: {file_pattern}")
tfrecord_filenames = tf.io.gfile.glob(file_pattern[0] + ".gz")
dataset = tf.data.TFRecordDataset(tfrecord_filenames, compression_type="GZIP")
dataset = dataset.map(_parse_fn).batch(batch_size)
return dataset.repeat()
def _make_keras_model() -> tf.keras.Model:
"""Creates a MobileNetV3-based model for classifying flowers data.
Returns:
A Keras Model.
"""
inputs = keras.Input(shape=_INPUT_SHAPE)
base_model = keras.applications.MobileNetV3Small(
include_top=False, input_shape=_INPUT_SHAPE, pooling="avg"
)
base_model.trainable = False
x = keras.applications.mobilenet_v3.preprocess_input(inputs)
x = base_model(
x, training=False
) # Ensures BatchNorm runs in inference model in this model
outputs = keras.layers.Dense(5, activation="softmax")(x)
model = keras.Model(inputs, outputs)
model.compile(
optimizer=keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=[keras.metrics.SparseCategoricalAccuracy()],
)
model.summary(print_fn=logging.info)
return model
# TFX Trainer will call this function.
def run_fn(fn_args: tfx.components.FnArgs):
"""Train the model based on given args.
Args:
fn_args: Holds args used to train the model as name/value pairs.
"""
train_dataset = _input_fn(fn_args.train_files, batch_size=_TRAIN_BATCH_SIZE)
eval_dataset = _input_fn(fn_args.eval_files, batch_size=_EVAL_BATCH_SIZE)
model = _make_keras_model()
model.fit(
train_dataset,
steps_per_epoch=fn_args.train_steps,
validation_data=eval_dataset,
validation_steps=fn_args.eval_steps,
epochs=_EPOCHS,
)
_, acc = model.evaluate(eval_dataset, steps=fn_args.eval_steps)
logging.info(f"Validation accuracy: {round(acc * 100, 2)}%")
# Convert the model.
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
# Save the model.
# The result of the training should be saved in `fn_args.serving_model_dir` directory.
with tf.io.gfile.GFile(fn_args.serving_model_dir + "/model.tflite", "wb") as f:
f.write(tflite_model)
|
sayakpaul/Dual-Deployments-on-Vertex-AI | custom_components/vertex_deployer.py | """
Custom TFX component for deploying a model to a Vertex AI Endpoint.
Author: Sayak Paul
Reference: https://github.com/GoogleCloudPlatform/mlops-with-vertex-ai/blob/main/build/utils.py#L97
"""
from tfx.dsl.component.experimental.decorators import component
from tfx.dsl.component.experimental.annotations import Parameter
from tfx.types.standard_artifacts import String
from google.cloud import aiplatform as vertex_ai
from tfx import v1 as tfx
from absl import logging
@component
def VertexDeployer(
project: Parameter[str],
region: Parameter[str],
model_display_name: Parameter[str],
deployed_model_display_name: Parameter[str],
):
logging.info(f"Endpoint display: {deployed_model_display_name}")
vertex_ai.init(project=project, location=region)
endpoints = vertex_ai.Endpoint.list(
filter=f"display_name={deployed_model_display_name}", order_by="update_time"
)
if len(endpoints) > 0:
logging.info(f"Endpoint {deployed_model_display_name} already exists.")
endpoint = endpoints[-1]
else:
endpoint = vertex_ai.Endpoint.create(deployed_model_display_name)
model = vertex_ai.Model.list(
filter=f"display_name={model_display_name}", order_by="update_time"
)[-1]
endpoint = vertex_ai.Endpoint.list(
filter=f"display_name={deployed_model_display_name}", order_by="update_time"
)[-1]
deployed_model = endpoint.deploy(
model=model,
# Syntax from here: https://git.io/JBQDP
traffic_split={"0": 100},
machine_type="n1-standard-4",
min_replica_count=1,
max_replica_count=1,
)
logging.info(f"Model deployed to: {deployed_model}")
|
sayakpaul/Dual-Deployments-on-Vertex-AI | custom_components/vertex_uploader.py | """
Custom TFX component for importing a model into Vertex AI.
Author: Sayak Paul
Reference: https://github.com/GoogleCloudPlatform/mlops-with-vertex-ai/blob/main/src/tfx_pipelines/components.py#L74
"""
import os
import tensorflow as tf
from tfx.dsl.component.experimental.decorators import component
from tfx.dsl.component.experimental.annotations import Parameter
from tfx.types.standard_artifacts import String
from google.cloud import aiplatform as vertex_ai
from tfx import v1 as tfx
from absl import logging
@component
def VertexUploader(
project: Parameter[str],
region: Parameter[str],
model_display_name: Parameter[str],
pushed_model_location: Parameter[str],
serving_image_uri: Parameter[str],
uploaded_model: tfx.dsl.components.OutputArtifact[String],
):
vertex_ai.init(project=project, location=region)
pushed_model_dir = os.path.join(
pushed_model_location, tf.io.gfile.listdir(pushed_model_location)[-1]
)
logging.info(f"Model registry location: {pushed_model_dir}")
vertex_model = vertex_ai.Model.upload(
display_name=model_display_name,
artifact_uri=pushed_model_dir,
serving_container_image_uri=serving_image_uri,
parameters_schema_uri=None,
instance_schema_uri=None,
explanation_metadata=None,
explanation_parameters=None,
)
uploaded_model.set_string_custom_property(
"model_resource_name", str(vertex_model.resource_name)
)
logging.info(f"Model resource: {str(vertex_model.resource_name)}")
|
sayakpaul/Dual-Deployments-on-Vertex-AI | notebooks/Custom_Model_TFX.ipynb | from google.colab import auth
auth.authenticate_user()import tensorflow as tf
print('TensorFlow version: {}'.format(tf.__version__))
from tfx import v1 as tfx
print('TFX version: {}'.format(tfx.__version__))
import kfp
print('KFP version: {}'.format(kfp.__version__))
from google.cloud import aiplatform as vertex_ai
import osGOOGLE_CLOUD_PROJECT = 'fast-ai-exploration' #@param {type:"string"}
GOOGLE_CLOUD_REGION = 'us-central1' #@param {type:"string"}
GCS_BUCKET_NAME = 'vertex-tfx-mlops' #@param {type:"string"}
if not (GOOGLE_CLOUD_PROJECT and GOOGLE_CLOUD_REGION and GCS_BUCKET_NAME):
from absl import logging
logging.error('Please set all required parameters.')PIPELINE_NAME = 'two-way-vertex-pipelines5'
# Path to various pipeline artifact.
PIPELINE_ROOT = 'gs://{}/pipeline_root/{}'.format(
GCS_BUCKET_NAME, PIPELINE_NAME)
# Paths for users' Python module.
MODULE_ROOT = 'gs://{}/pipeline_module/{}'.format(
GCS_BUCKET_NAME, PIPELINE_NAME)
# Paths for input data.
DATA_ROOT = 'gs://flowers-public/tfrecords-jpeg-224x224'
# This is the path where your model will be pushed for serving.
SERVING_MODEL_DIR = 'gs://{}/serving_model/{}'.format(
GCS_BUCKET_NAME, PIPELINE_NAME)
print('PIPELINE_ROOT: {}'.format(PIPELINE_ROOT))FIREBASE_CREDENTIAL_PATH = 'gs://credential-csp/gcp-ml-172005-firebase-adminsdk-5gdtb-38c6644f1e.json'
FIREBASE_GCS_BUCKET = 'gcp-ml-172005.appspot.com'_trainer_densenet_module_file = 'flower_densenet_trainer.py'
_trainer_mobilenet_module_file = 'flower_mobilenet_trainer.py'%%writefile {_trainer_densenet_module_file}
from typing import List
from absl import logging
from tensorflow import keras
from tfx import v1 as tfx
import tensorflow as tf
_IMAGE_FEATURES = {
"image": tf.io.FixedLenFeature([], tf.string),
"class": tf.io.FixedLenFeature([], tf.int64),
"one_hot_class": tf.io.VarLenFeature(tf.float32),
}
_CONCRETE_INPUT = "numpy_inputs"
_INPUT_SHAPE = (224, 224, 3)
_TRAIN_BATCH_SIZE = 64
_EVAL_BATCH_SIZE = 64
_EPOCHS = 2
def _parse_fn(example):
example = tf.io.parse_single_example(example, _IMAGE_FEATURES)
image = tf.image.decode_jpeg(example["image"], channels=3)
class_label = tf.cast(example["class"], tf.int32)
return image, class_label
def _input_fn(file_pattern: List[str], batch_size: int) -> tf.data.Dataset:
"""Generates features and label for training.
Args:
file_pattern: List of paths or patterns of input tfrecord files.
batch_size: representing the number of consecutive elements of returned
dataset to combine in a single batch.
Returns:
A dataset that contains (features, indices) tuple where features is a
dictionary of Tensors, and indices is a single Tensor of label indices.
"""
logging.info(f"Reading data from: {file_pattern}")
tfrecord_filenames = tf.io.gfile.glob(file_pattern[0] + ".gz")
dataset = tf.data.TFRecordDataset(tfrecord_filenames, compression_type="GZIP")
dataset = dataset.map(_parse_fn).batch(batch_size)
return dataset.repeat()
def _make_keras_model() -> tf.keras.Model:
"""Creates a DenseNet121-based model for classifying flowers data.
Returns:
A Keras Model.
"""
inputs = keras.Input(shape=_INPUT_SHAPE)
base_model = keras.applications.DenseNet121(
include_top=False, input_shape=_INPUT_SHAPE, pooling="avg"
)
base_model.trainable = False
x = keras.applications.densenet.preprocess_input(inputs)
x = base_model(
x, training=False
) # Ensures BatchNorm runs in inference model in this model
outputs = keras.layers.Dense(5, activation="softmax")(x)
model = keras.Model(inputs, outputs)
model.compile(
optimizer=keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=[keras.metrics.SparseCategoricalAccuracy()],
)
model.summary(print_fn=logging.info)
return model
def _preprocess(bytes_input):
decoded = tf.io.decode_jpeg(bytes_input, channels=3)
resized = tf.image.resize(decoded, size=(224, 224))
return resized
@tf.function(input_signature=[tf.TensorSpec([None], tf.string)])
def preprocess_fn(bytes_inputs):
decoded_images = tf.map_fn(
_preprocess, bytes_inputs, dtype=tf.float32, back_prop=False
)
return {_CONCRETE_INPUT: decoded_images}
def _model_exporter(model: tf.keras.Model):
m_call = tf.function(model.call).get_concrete_function(
[
tf.TensorSpec(
shape=[None, 224, 224, 3], dtype=tf.float32, name=_CONCRETE_INPUT
)
]
)
@tf.function(input_signature=[tf.TensorSpec([None], tf.string)])
def serving_fn(bytes_inputs):
labels = tf.constant(
["daisy", "dandelion", "roses", "sunflowers", "tulips"], dtype=tf.string
)
images = preprocess_fn(bytes_inputs)
probs = m_call(**images)
indices = tf.argmax(probs, axis=1)
pred_source = tf.gather(params=labels, indices=indices)
pred_confidence = tf.reduce_max(probs, axis=1)
return {"label": pred_source, "confidence": pred_confidence}
return serving_fn
# TFX Trainer will call this function.
def run_fn(fn_args: tfx.components.FnArgs):
"""Train the model based on given args.
Args:
fn_args: Holds args used to train the model as name/value pairs.
"""
train_dataset = _input_fn(fn_args.train_files, batch_size=_TRAIN_BATCH_SIZE)
eval_dataset = _input_fn(fn_args.eval_files, batch_size=_EVAL_BATCH_SIZE)
model = _make_keras_model()
model.fit(
train_dataset,
steps_per_epoch=fn_args.train_steps,
validation_data=eval_dataset,
validation_steps=fn_args.eval_steps,
epochs=_EPOCHS,
)
_, acc = model.evaluate(eval_dataset, steps=fn_args.eval_steps)
logging.info(f"Validation accuracy: {round(acc * 100, 2)}%")
# The result of the training should be saved in `fn_args.serving_model_dir`
# directory.
tf.saved_model.save(
model,
fn_args.serving_model_dir,
signatures={"serving_default": _model_exporter(model)},
)
%%writefile {_trainer_mobilenet_module_file}
from typing import List
from absl import logging
from tensorflow import keras
from tfx import v1 as tfx
import tensorflow as tf
_IMAGE_FEATURES = {
"image": tf.io.FixedLenFeature([], tf.string),
"class": tf.io.FixedLenFeature([], tf.int64),
"one_hot_class": tf.io.VarLenFeature(tf.float32),
}
_INPUT_SHAPE = (224, 224, 3)
_TRAIN_BATCH_SIZE = 64
_EVAL_BATCH_SIZE = 64
_EPOCHS = 2
def _parse_fn(example):
example = tf.io.parse_single_example(example, _IMAGE_FEATURES)
image = tf.image.decode_jpeg(example["image"], channels=3)
class_label = tf.cast(example["class"], tf.int32)
return image, class_label
def _input_fn(file_pattern: List[str], batch_size: int) -> tf.data.Dataset:
"""Generates features and label for training.
Args:
file_pattern: List of paths or patterns of input tfrecord files.
batch_size: representing the number of consecutive elements of returned
dataset to combine in a single batch.
Returns:
A dataset that contains (features, indices) tuple where features is a
dictionary of Tensors, and indices is a single Tensor of label indices.
"""
logging.info(f"Reading data from: {file_pattern}")
tfrecord_filenames = tf.io.gfile.glob(file_pattern[0] + ".gz")
dataset = tf.data.TFRecordDataset(tfrecord_filenames, compression_type="GZIP")
dataset = dataset.map(_parse_fn).batch(batch_size)
return dataset.repeat()
def _make_keras_model() -> tf.keras.Model:
"""Creates a MobileNetV3-based model for classifying flowers data.
Returns:
A Keras Model.
"""
inputs = keras.Input(shape=_INPUT_SHAPE)
base_model = keras.applications.MobileNetV3Small(
include_top=False, input_shape=_INPUT_SHAPE, pooling="avg"
)
base_model.trainable = False
x = keras.applications.mobilenet_v3.preprocess_input(inputs)
x = base_model(
x, training=False
) # Ensures BatchNorm runs in inference model in this model
outputs = keras.layers.Dense(5, activation="softmax")(x)
model = keras.Model(inputs, outputs)
model.compile(
optimizer=keras.optimizers.Adam(),
loss=tf.keras.losses.SparseCategoricalCrossentropy(),
metrics=[keras.metrics.SparseCategoricalAccuracy()],
)
model.summary(print_fn=logging.info)
return model
# TFX Trainer will call this function.
def run_fn(fn_args: tfx.components.FnArgs):
"""Train the model based on given args.
Args:
fn_args: Holds args used to train the model as name/value pairs.
"""
train_dataset = _input_fn(fn_args.train_files, batch_size=_TRAIN_BATCH_SIZE)
eval_dataset = _input_fn(fn_args.eval_files, batch_size=_EVAL_BATCH_SIZE)
model = _make_keras_model()
model.fit(
train_dataset,
steps_per_epoch=fn_args.train_steps,
validation_data=eval_dataset,
validation_steps=fn_args.eval_steps,
epochs=_EPOCHS,
)
_, acc = model.evaluate(eval_dataset, steps=fn_args.eval_steps)
logging.info(f"Validation accuracy: {round(acc * 100, 2)}%")
# Convert the model.
converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]
tflite_model = converter.convert()
# Save the model.
# The result of the training should be saved in `fn_args.serving_model_dir` directory.
with tf.io.gfile.GFile(fn_args.serving_model_dir + "/model.tflite", "wb") as f:
f.write(tflite_model)
_vertex_uploader_module_file = 'vertex_uploader.py'
_vertex_deployer_module_file = 'vertex_deployer.py'
_firebase_publisher_module_file = 'firebase_publisher.py'%%writefile {_vertex_uploader_module_file}
import os
import tensorflow as tf
from tfx.dsl.component.experimental.decorators import component
from tfx.dsl.component.experimental.annotations import Parameter
from tfx.types.standard_artifacts import String
from google.cloud import aiplatform as vertex_ai
from tfx import v1 as tfx
from absl import logging
@component
def VertexUploader(
project: Parameter[str],
region: Parameter[str],
model_display_name: Parameter[str],
pushed_model_location: Parameter[str],
serving_image_uri: Parameter[str],
uploaded_model: tfx.dsl.components.OutputArtifact[String],
):
vertex_ai.init(project=project, location=region)
pushed_model_dir = os.path.join(
pushed_model_location, tf.io.gfile.listdir(pushed_model_location)[-1]
)
logging.info(f"Model registry location: {pushed_model_dir}")
vertex_model = vertex_ai.Model.upload(
display_name=model_display_name,
artifact_uri=pushed_model_dir,
serving_container_image_uri=serving_image_uri,
parameters_schema_uri=None,
instance_schema_uri=None,
explanation_metadata=None,
explanation_parameters=None,
)
uploaded_model.set_string_custom_property(
"model_resource_name", str(vertex_model.resource_name)
)
logging.info(f"Model resource: {str(vertex_model.resource_name)}")
%%writefile {_vertex_deployer_module_file}
from tfx.dsl.component.experimental.decorators import component
from tfx.dsl.component.experimental.annotations import Parameter
from tfx.types.standard_artifacts import String
from google.cloud import aiplatform as vertex_ai
from tfx import v1 as tfx
from absl import logging
@component
def VertexDeployer(
project: Parameter[str],
region: Parameter[str],
model_display_name: Parameter[str],
deployed_model_display_name: Parameter[str],
):
logging.info(f"Endpoint display: {deployed_model_display_name}")
vertex_ai.init(project=project, location=region)
endpoints = vertex_ai.Endpoint.list(
filter=f"display_name={deployed_model_display_name}", order_by="update_time"
)
if len(endpoints) > 0:
logging.info(f"Endpoint {deployed_model_display_name} already exists.")
endpoint = endpoints[-1]
else:
endpoint = vertex_ai.Endpoint.create(deployed_model_display_name)
model = vertex_ai.Model.list(
filter=f"display_name={model_display_name}", order_by="update_time"
)[-1]
endpoint = vertex_ai.Endpoint.list(
filter=f"display_name={deployed_model_display_name}", order_by="update_time"
)[-1]
deployed_model = endpoint.deploy(
model=model,
# Syntax from here: https://git.io/JBQDP
traffic_split={"0": 100},
machine_type="n1-standard-4",
min_replica_count=1,
max_replica_count=1,
)
logging.info(f"Model deployed to: {deployed_model}")
%%writefile {_firebase_publisher_module_file}
from tfx import types
from tfx.dsl.component.experimental.decorators import component
from tfx.dsl.component.experimental.annotations import Parameter
from tfx import v1 as tfx
from absl import logging
import firebase_admin
from firebase_admin import ml
from firebase_admin import storage
from firebase_admin import credentials
from google.cloud import storage as gcs_storage
@component
def FirebasePublisher(
pushed_model: tfx.dsl.components.InputArtifact[
tfx.types.standard_artifacts.PushedModel
],
credential_uri: Parameter[str],
firebase_dest_gcs_bucket: Parameter[str],
model_display_name: Parameter[str],
model_tag: Parameter[str],
) -> tfx.dsl.components.OutputDict(result=str):
model_uri = f"{pushed_model.uri}/model.tflite"
assert model_uri.split("://")[0] == "gs"
assert credential_uri.split("://")[0] == "gs"
# create gcs client instance
gcs_client = gcs_storage.Client()
# get credential for firebase
credential_gcs_bucket = credential_uri.split("//")[1].split("/")[0]
credential_blob_path = "/".join(credential_uri.split("//")[1].split("/")[1:])
bucket = gcs_client.bucket(credential_gcs_bucket)
blob = bucket.blob(credential_blob_path)
blob.download_to_filename("credential.json")
logging.info(f"download credential.json from {credential_uri} is completed")
# get tflite model file
tflite_gcs_bucket = model_uri.split("//")[1].split("/")[0]
tflite_blob_path = "/".join(model_uri.split("//")[1].split("/")[1:])
bucket = gcs_client.bucket(tflite_gcs_bucket)
blob = bucket.blob(tflite_blob_path)
blob.download_to_filename("model.tflite")
logging.info(f"download model.tflite from {model_uri} is completed")
firebase_admin.initialize_app(
credentials.Certificate("credential.json"),
options={"storageBucket": firebase_dest_gcs_bucket},
)
logging.info("firebase_admin initialize app is completed")
model_list = ml.list_models(list_filter=f"display_name={model_display_name}")
# update
if len(model_list.models) > 0:
# get the first match model
model = model_list.models[0]
source = ml.TFLiteGCSModelSource.from_tflite_model_file("model.tflite")
model.model_format = ml.TFLiteFormat(model_source=source)
updated_model = ml.update_model(model)
ml.publish_model(updated_model.model_id)
logging.info("model exists, so update it in FireBase ML")
return {"result": "model updated"}
# create
else:
# load a tflite file and upload it to Cloud Storage
source = ml.TFLiteGCSModelSource.from_tflite_model_file("model.tflite")
# create the model object
tflite_format = ml.TFLiteFormat(model_source=source)
model = ml.Model(
display_name=model_display_name,
tags=[model_tag],
model_format=tflite_format,
)
# Add the model to your Firebase project and publish it
new_model = ml.create_model(model)
ml.publish_model(new_model.model_id)
logging.info("model doesn exists, so create one in FireBase ML")
return {"result": "model created"}
DATASET_DISPLAY_NAME = "flowers"
VERSION = "tfx-1-0-0"
TFX_IMAGE_URI = f"gcr.io/{GOOGLE_CLOUD_PROJECT}/{DATASET_DISPLAY_NAME}:{VERSION}"
print(f"URI of the custom image: {TFX_IMAGE_URI}")%%writefile Dockerfile
FROM gcr.io/tfx-oss-public/tfx:1.0.0
RUN mkdir -p custom_components
COPY custom_components/* ./custom_components/
RUN pip install --upgrade google-cloud-aiplatform google-cloud-storage firebase-admin# Specify training worker configurations. To minimize costs we can even specify two
# different configurations: a beefier machine for the Endpoint model and slightly less
# powerful machine for the mobile model.
TRAINING_JOB_SPEC = {
'project': GOOGLE_CLOUD_PROJECT,
'worker_pool_specs': [{
'machine_spec': {
'machine_type': 'n1-standard-4',
'accelerator_type': 'NVIDIA_TESLA_K80',
'accelerator_count': 1
},
'replica_count': 1,
'container_spec': {
'image_uri': 'gcr.io/tfx-oss-public/tfx:{}'.format(tfx.__version__),
},
}],
}from datetime import datetime
TIMESTAMP = datetime.now().strftime("%Y%m%d%H%M%S")from custom_components.vertex_uploader import VertexUploader
from custom_components.vertex_deployer import VertexDeployer
from custom_components.firebase_publisher import FirebasePublisher
def _create_pipeline(
pipeline_name: str,
pipeline_root: str,
data_root: str,
densenet_module_file: str,
mobilenet_module_file: str,
serving_model_dir: str,
firebase_crediential_path: str,
firebase_gcs_bucket: str,
project_id: str,
region: str,
) -> tfx.dsl.Pipeline:
"""Creates a three component flowers pipeline with TFX."""
# Brings data into the pipeline.
# input_base: gs://flowers-public/tfrecords-jpeg-224x224
example_gen = tfx.components.ImportExampleGen(input_base=data_root)
# Uses user-provided Python function that trains a model.
densenet_trainer = tfx.extensions.google_cloud_ai_platform.Trainer(
module_file=densenet_module_file,
examples=example_gen.outputs["examples"],
train_args=tfx.proto.TrainArgs(num_steps=52),
eval_args=tfx.proto.EvalArgs(num_steps=5),
custom_config={
tfx.extensions.google_cloud_ai_platform.ENABLE_UCAIP_KEY: True,
tfx.extensions.google_cloud_ai_platform.UCAIP_REGION_KEY: region,
tfx.extensions.google_cloud_ai_platform.TRAINING_ARGS_KEY: TRAINING_JOB_SPEC,
"use_gpu": True,
},
).with_id("densenet_trainer")
# Pushes the model to a filesystem destination.
pushed_model_location = os.path.join(serving_model_dir, "densenet")
densnet_pusher = tfx.components.Pusher(
model=densenet_trainer.outputs["model"],
push_destination=tfx.proto.PushDestination(
filesystem=tfx.proto.PushDestination.Filesystem(
base_directory=pushed_model_location
)
),
).with_id("densnet_pusher")
# Vertex AI upload.
model_display_name = "densenet_flowers_latest"
uploader = VertexUploader(
project=project_id,
region=region,
model_display_name=model_display_name,
pushed_model_location=pushed_model_location,
serving_image_uri="us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-5:latest",
).with_id("vertex_uploader")
uploader.add_upstream_node(densnet_pusher)
# Create an endpoint.
deployer = VertexDeployer(
project=project_id,
region=region,
model_display_name=model_display_name,
deployed_model_display_name=model_display_name + "_" + TIMESTAMP,
).with_id("vertex_deployer")
deployer.add_upstream_node(uploader)
# We repeat the steps for the MobileNet model too but this time we won't
# be creating an Endpoint. We will first convert the Keras model to TFLite
# and then push it to Firebase for better operability.
mobilenet_trainer = tfx.extensions.google_cloud_ai_platform.Trainer(
module_file=mobilenet_module_file,
examples=example_gen.outputs["examples"],
train_args=tfx.proto.TrainArgs(num_steps=52),
eval_args=tfx.proto.EvalArgs(num_steps=5),
custom_config={
tfx.extensions.google_cloud_ai_platform.ENABLE_UCAIP_KEY: True,
tfx.extensions.google_cloud_ai_platform.UCAIP_REGION_KEY: region,
tfx.extensions.google_cloud_ai_platform.TRAINING_ARGS_KEY: TRAINING_JOB_SPEC,
"use_gpu": True,
},
).with_id("mobilenet_trainer")
pushed_location_mobilenet = os.path.join(serving_model_dir, "mobilenet")
mobilenet_pusher = tfx.components.Pusher(
model=mobilenet_trainer.outputs["model"],
push_destination=tfx.proto.PushDestination(
filesystem=tfx.proto.PushDestination.Filesystem(
base_directory=pushed_location_mobilenet
)
),
).with_id("mobilenet_pusher")
firebase_publisher = FirebasePublisher(
pushed_model=mobilenet_pusher.outputs["pushed_model"],
credential_uri=firebase_crediential_path,
firebase_dest_gcs_bucket=firebase_gcs_bucket,
model_display_name=model_display_name,
model_tag="mobilenet",
).with_id("firebase_publisher")
# Following components will be included in the pipeline.
components = [
example_gen,
densenet_trainer,
densnet_pusher,
uploader,
deployer,
mobilenet_trainer,
mobilenet_pusher,
firebase_publisher,
]
return tfx.dsl.Pipeline(
pipeline_name=pipeline_name, pipeline_root=pipeline_root, components=components
)
PIPELINE_DEFINITION_FILE = PIPELINE_NAME + '_pipeline.json'
# Important: We need to pass the custom Docker image URI to the
# `KubeflowV2DagRunnerConfig` to take effect.
runner = tfx.orchestration.experimental.KubeflowV2DagRunner(
config=tfx.orchestration.experimental.KubeflowV2DagRunnerConfig(default_image=TFX_IMAGE_URI),
output_filename=PIPELINE_DEFINITION_FILE)
_ = runner.run(
_create_pipeline(
pipeline_name=PIPELINE_NAME,
pipeline_root=PIPELINE_ROOT,
data_root=DATA_ROOT,
densenet_module_file=os.path.join(MODULE_ROOT, _trainer_densenet_module_file),
mobilenet_module_file=os.path.join(MODULE_ROOT, _trainer_mobilenet_module_file),
serving_model_dir=SERVING_MODEL_DIR,
firebase_crediential_path=FIREBASE_CREDENTIAL_PATH,
firebase_gcs_bucket=FIREBASE_GCS_BUCKET,
project_id=GOOGLE_CLOUD_PROJECT,
region=GOOGLE_CLOUD_REGION
)
)from kfp.v2.google import client
pipelines_client = client.AIPlatformClient(
project_id=GOOGLE_CLOUD_PROJECT,
region=GOOGLE_CLOUD_REGION,
)
_ = pipelines_client.create_run_from_job_spec(PIPELINE_DEFINITION_FILE, enable_caching=True)from google.cloud.aiplatform import gapic as aip
from google.protobuf import json_format
from google.protobuf.json_format import MessageToJson, ParseDict
from google.protobuf.struct_pb2 import Struct, Value
import base64vertex_ai.init(project=GOOGLE_CLOUD_PROJECT, location=GOOGLE_CLOUD_REGION)model_display_name = "densenet_flowers_latest"
deployed_model_display_name = model_display_name + "_" + TIMESTAMP
endpoint = vertex_ai.Endpoint.list(
filter=f'display_name={deployed_model_display_name}',
order_by="update_time"
)[-1]
endpoint_id = endpoint.name
endpoint_idimage_path = tf.keras.utils.get_file("image.jpg",
"https://m.economictimes.com/thumb/msid-71307470,width-1201,height-900,resizemode-4,imgsize-1040796/roses.jpg")
bytes = tf.io.read_file(image_path)
b64str = base64.b64encode(bytes.numpy()).decode("utf-8")pushed_model_location = os.path.join(SERVING_MODEL_DIR, "densenet")
model_path_to_deploy = os.path.join(
pushed_model_location, tf.io.gfile.listdir(pushed_model_location)[-1]
)
loaded = tf.saved_model.load(model_path_to_deploy)
serving_input = list(
loaded.signatures["serving_default"].structured_input_signature[1].keys()
)[0]
print("Serving function input:", serving_input)def predict_image(image, endpoint, parameters_dict):
# The format of each instance should conform to the deployed model's prediction input schema.
instances_list = [{serving_input: {"b64": image}}]
instances = [json_format.ParseDict(s, Value()) for s in instances_list]
endpoint = vertex_ai.Endpoint(endpoint)
print(endpoint.predict(instances=instances))
predict_image(b64str, endpoint_id, None) |
sayakpaul/Dual-Deployments-on-Vertex-AI | notebooks/Dataset_Prep.ipynb | #@title GCS
#@markdown You should change these values as per your preferences. The copy operation can take ~5 minutes.
BUCKET_PATH = "gs://flowers-experimental" #@param {type:"string"}
REGION = "us-central1" #@param {type:"string"}
!gsutil mb -l {REGION} {BUCKET_PATH}
!gsutil -m cp -r flower_photos {BUCKET_PATH}import random
random.seed(666)
from google.cloud import storage
from pprint import pprint
import pandas as pd
import osfrom google.colab import auth
auth.authenticate_user()gs_uris = []
storage_client = storage.Client(project="fast-ai-exploration") # Change it accordingly.
blobs = storage_client.list_blobs(BUCKET_PATH.split("/")[-1])
for blob in blobs:
if ".txt" in blob.name.split("/")[-1]:
continue
gs_uri = os.path.join(BUCKET_PATH, blob.name)
gs_uris.append(gs_uri)
pprint(gs_uris[:5])# Create splits.
random.shuffle(gs_uris)
i = int(len(gs_uris) * 0.9)
train_paths = gs_uris[:i]
test_paths = gs_uris[i:]
i = int(len(train_paths) * 0.05)
valid_paths = train_paths[:i]
train_paths = train_paths[i:]
print(len(train_paths), len(valid_paths), len(test_paths))def derive_labels(gcs_paths, split="training"):
labels = []
for gcs_path in gcs_paths:
label = gcs_path.split("/")[4]
labels.append(label)
return labels, [split] * len(gcs_paths)# File format is referred from: https://cloud.google.com/vertex-ai/docs/datasets/prepare-image#csv
train_labels, train_use = derive_labels(train_paths)
val_labels, val_use = derive_labels(valid_paths, split="validation")
test_labels, test_use= derive_labels(test_paths, split="test")gcs_uris = []
labels = []
use = []
gcs_uris.extend(train_paths)
gcs_uris.extend(valid_paths)
gcs_uris.extend(test_paths)
labels.extend(train_labels)
labels.extend(val_labels)
labels.extend(test_labels)
use.extend(train_use)
use.extend(val_use)
use.extend(test_use)import csv
with open("flowers_vertex.csv", "w") as csvfile:
csvwriter = csv.writer(csvfile)
for ml_use, gcs_uri, label in zip(use, gcs_uris, labels):
row = [ml_use, gcs_uri, label]
csvwriter.writerow(row) |
sayakpaul/Dual-Deployments-on-Vertex-AI | notebooks/Dual_Deployments_With_AutoML.ipynb | import os
# The Google Cloud Notebook product has specific requirements
IS_GOOGLE_CLOUD_NOTEBOOK = os.path.exists("/opt/deeplearning/metadata/env_version")
# Google Cloud Notebook requires dependencies to be installed with '--user'
USER_FLAG = ""
if IS_GOOGLE_CLOUD_NOTEBOOK:
USER_FLAG = "--user"# Automatically restart kernel after installs
import os
if not os.getenv("IS_TESTING"):
# Automatically restart kernel after installs
import IPython
app = IPython.Application.instance()
app.kernel.do_shutdown(True)import os
PROJECT_ID = "grounded-atrium-320207"
# Get your Google Cloud project ID from gcloud
if not os.getenv("IS_TESTING"):
shell_output=!gcloud config list --format 'value(core.project)' 2>/dev/null
PROJECT_ID = shell_output[0]
print("Project ID: ", PROJECT_ID)import os
import sys
# If you are running this notebook in Colab, run this cell and follow the
# instructions to authenticate your GCP account. This provides access to your
# Cloud Storage bucket and lets you submit training jobs and prediction
# requests.
# The Google Cloud Notebook product has specific requirements
IS_GOOGLE_CLOUD_NOTEBOOK = os.path.exists("/opt/deeplearning/metadata/env_version")
# If on Google Cloud Notebooks, then don't execute this code
if not IS_GOOGLE_CLOUD_NOTEBOOK:
if "google.colab" in sys.modules:
from google.colab import auth as google_auth
google_auth.authenticate_user()
# If you are running this notebook locally, replace the string below with the
# path to your service account key and run this cell to authenticate your GCP
# account.
elif not os.getenv("IS_TESTING"):
%env GOOGLE_APPLICATION_CREDENTIALS ''BUCKET_NAME = "gs://vertexai_dual_example"
REGION = "us-central1" PATH=%env PATH
%env PATH={PATH}:/home/jupyter/.local/bin
USER = "chansung"
PIPELINE_ROOT = "{}/pipeline_root/{}".format(BUCKET_NAME, USER)
PIPELINE_ROOTimport kfp
from google.cloud import aiplatform
from google_cloud_pipeline_components import aiplatform as gcc_aip
from kfp.v2 import compiler
from kfp.v2.google.client import AIPlatformClient
from kfp.v2 import dsl
from kfp.v2.dsl import component@component(
packages_to_install=["google-cloud-storage", "firebase-admin", "tensorflow"]
)
def push_to_firebase(
credential_uri: str,
model_bucket: str,
firebase_dest_gcs_bucket: str,
model_display_name: str,
model_tag: str
):
import firebase_admin
from firebase_admin import ml
from firebase_admin import storage
from firebase_admin import credentials
from google.cloud import storage as gcs_storage
gcs_client = gcs_storage.Client()
# get credential for firebase
credential_gcs_bucket = credential_uri.split('//')[1].split('/')[0]
credential_blob_path = '/'.join(credential_uri.split('//')[1].split('/')[1:])
bucket = gcs_client.bucket(credential_gcs_bucket)
blob = bucket.blob(credential_blob_path)
blob.download_to_filename('credential.json')
# get the latest model
tflite_blobs = gcs_client.get_bucket(model_bucket).list_blobs()
tflite_blob = sorted(tflite_blobs, reverse=True, key=lambda blob: blob.name.split('/')[-2])[0]
tflite_blob.download_to_filename('model.tflite')
firebase_admin.initialize_app(
credentials.Certificate('credential.json'),
options={
'storageBucket': firebase_dest_gcs_bucket
}
)
model_list = ml.list_models(list_filter=f'display_name={model_display_name}')
# update
if len(model_list.models) > 0:
# get the first match model
model = model_list.models[0]
source = ml.TFLiteGCSModelSource.from_tflite_model_file('model.tflite')
model.model_format = ml.TFLiteFormat(model_source=source)
updated_model = ml.update_model(model)
ml.publish_model(updated_model.model_id)
# create
else:
# Load a tflite file and upload it to Cloud Storage
source = ml.TFLiteGCSModelSource.from_tflite_model_file('model.tflite')
# Create the model object
tflite_format = ml.TFLiteFormat(model_source=source)
model = ml.Model(
display_name=model_display_name, # This is the name you use from your app to load the model.
tags=[model_tag], # Optional tags for easier management.
model_format=tflite_format)
# Add the model to your Firebase project and publish it
new_model = ml.create_model(model)
ml.publish_model(new_model.model_id)@kfp.dsl.pipeline(name="cloud-mobile-dual-deployment")
def pipeline(project: str = PROJECT_ID):
ds_op = gcc_aip.ImageDatasetCreateOp(
project=project,
display_name="flowers-dataset",
gcs_source="gs://dataset-meta-gde-csp/flowers_vertex.csv",
import_schema_uri=aiplatform.schema.dataset.ioformat.image.multi_label_classification,
)
configs = [
{
"type": "CLOUD",
"model_type": "CLOUD",
"display_name": "train-cloud-model",
"model_display_name": "cloud-model",
"budget_milli_node_hours": 8000,
},
{
"type": "MOBILE",
"model_type": "MOBILE_TF_VERSATILE_1",
"display_name": "train-mobile-model",
"model_display_name": "mobile-model",
"budget_milli_node_hours": 1000,
}
]
with kfp.dsl.ParallelFor(configs) as config:
training_job_run_op = gcc_aip.AutoMLImageTrainingJobRunOp(
project=project,
display_name=config.display_name,
prediction_type="classification",
multi_label=True,
model_type=config.model_type,
base_model=None,
dataset=ds_op.outputs["dataset"],
model_display_name=config.model_display_name,
budget_milli_node_hours=config.budget_milli_node_hours,
)
training_job_run_op.after(ds_op)
with kfp.dsl.Condition(config.type=='CLOUD'):
endpoint_op = gcc_aip.ModelDeployOp(
project=project,
model=training_job_run_op.outputs["model"]
)
endpoint_op.after(training_job_run_op)
with kfp.dsl.Condition(config.type=='MOBILE'):
export_op = gcc_aip.ModelExportOp(
project=project,
model=training_job_run_op.outputs["model"],
# tflite, edgetpu-tflite, tf-saved-model, tf-js, core-ml, custom-trained
export_format_id="tflite",
artifact_destination="gs://output-model-gde-csp/flower-models/"
)
export_op.after(training_job_run_op)
credential_uri="gs://firebase-ml-bucket-gde-csp/grounded-atrium-320207-firebase-adminsdk-5n9sn-20dbda9947.json"
model_bucket="output-model-gde-csp"
firebase_bucket="grounded-atrium-320207.appspot.com"
firebase_op = push_to_firebase(
ins=export_op.outputs['exported_dataset'],
credential_uri=credential_uri,
model_bucket=model_bucket,
firebase_dest_gcs_bucket=firebase_bucket,
model_display_name="custom_model",
model_tag="from_dual_deployment"
)
firebase_op.after(export_op)
from kfp.v2 import compiler
compiler.Compiler().compile(
pipeline_func=pipeline, package_path="cloud-mobile-dual-deployment.json"
)from kfp.v2.google.client import AIPlatformClient
api_client = AIPlatformClient(project_id=PROJECT_ID, region=REGION)response = api_client.create_run_from_job_spec(
"cloud-mobile-dual-deployment.json",
pipeline_root=PIPELINE_ROOT,
parameter_values={"project": PROJECT_ID},
) |
sayakpaul/Dual-Deployments-on-Vertex-AI | notebooks/Model_Tests.ipynb | from io import BytesIO
from PIL import Image
import matplotlib.pyplot as plt
import numpy as np
import requests
import base64
from google.cloud.aiplatform.gapic.schema import predict
from google.cloud import aiplatform
import tensorflow as tfdef preprocess_image(image):
"""Preprocesses an image."""
image = np.array(image)
image = tf.image.resize(image, (224, 224))
image = tf.cast(image, tf.uint8)
return image[None, ...]
def load_image_from_url(url):
"""Loads an image from a URL. Please provide a URL of a valid RGB image."""
response = requests.get(url)
image = Image.open(BytesIO(response.content))
image = preprocess_image(image)
return image
def tflite_inference(tflite_model_path, image):
"""Runs inference with a TFLite model."""
# Load the TFLite model from its patth and allocate tensors into memory.
interpreter = tf.lite.Interpreter(model_path=tflite_model_path)
interpreter.allocate_tensors()
# Get the indices of input and output of the model.
input_details = interpreter.get_input_details()[0]
input_index = input_details["index"]
output_index = interpreter.get_output_details()[0]["index"]
# Scale if needed.
if input_details["dtype"] == np.uint8:
input_scale, input_zero_point = input_details["quantization"]
image = tf.cast(image, tf.float32)
image = image / input_scale + input_zero_point
image = tf.cast(image, tf.uint8)
# Run inference.
interpreter.set_tensor(input_index, image)
interpreter.invoke()
# Post-processing: remove batch dimension and find the digit with highest
# probability.
probability = interpreter.get_tensor(output_index)
flower_id = np.argmax(probability[0])
return flower_idimage = load_image_from_url("https://m.economictimes.com/thumb/msid-71307470,width-1201,height-900,resizemode-4,imgsize-1040796/roses.jpg")
plt.imshow(image[0])
plt.axis("off")
plt.show()tflite_model_path = tf.keras.utils.get_file("model.tflite",
"https://storage.googleapis.com/output-model-gde-csp/flower-models/model-8119506343032782848/tflite/2021-07-28T15%3A48%3A15.623623Z/model.tflite")CLASSES = ["daisy", "dandelion", "roses", "sunflowers", "tulips"]
CLASSES[tflite_inference(tflite_model_path, image)]from google.colab import auth
auth.authenticate_user()# Reference:
# https://cloud.google.com/vertex-ai/docs/predictions/online-predictions-automl
def predict_image_classification_sample(
project: str,
endpoint_id: str,
filename: str,
location: str = "us-central1",
api_endpoint: str = "us-central1-aiplatform.googleapis.com",
):
# The AI Platform services require regional API endpoints.
client_options = {"api_endpoint": api_endpoint}
# Initialize client that will be used to create and send requests.
# This client only needs to be created once, and can be reused for multiple requests.
client = aiplatform.gapic.PredictionServiceClient(client_options=client_options)
with open(filename, "rb") as f:
file_content = f.read()
# The format of each instance should conform to the deployed model's prediction input schema.
encoded_content = base64.b64encode(file_content).decode("utf-8")
instance = predict.instance.ImageClassificationPredictionInstance(
content=encoded_content,
).to_value()
instances = [instance]
# See gs://google-cloud-aiplatform/schema/predict/params/image_classification_1.0.0.yaml for the format of the parameters.
parameters = predict.params.ImageClassificationPredictionParams(
confidence_threshold=0.5, max_predictions=5,
).to_value()
endpoint = client.endpoint_path(
project=project, location=location, endpoint=endpoint_id
)
response = client.predict(
endpoint=endpoint, instances=instances, parameters=parameters
)
print("response")
print(" deployed_model_id:", response.deployed_model_id)
# See gs://google-cloud-aiplatform/schema/predict/prediction/classification.yaml for the format of the predictions.
predictions = response.predictions
for prediction in predictions:
print(" prediction:", dict(prediction))
image_path = tf.keras.utils.get_file("image.jpg",
"https://m.economictimes.com/thumb/msid-71307470,width-1201,height-900,resizemode-4,imgsize-1040796/roses.jpg")
predict_image_classification_sample(
project="881543627888",
endpoint_id="2892911849701900288",
location="us-central1",
filename=image_path
) |
- Downloads last month
- 0