Advanced Machine

Learning with
TensorFlow
22TCSE532
Name - Bavalpreet Singh
Email - Lecture_1.3
[email protected]
What is TensorFlow?
Definition: TensorFlow is an open-source machine learning platform ● Performance:
developed by Google. ○ Optimized for GPU and distributed computing
○ Supports parallel processing for faster computations
Core concept: It uses data flow graphs for numerical computations. ○ Offers both eager execution and graph execution modes

Versatility: Supports a wide range of machine learning and deep

● Ecosystem:
learning models.
○ Large and active community
○ Extensive documentation and tutorials
Key Features and Benefits ○ TensorFlow Extended (TFX) for full ML pipelines
○ TensorFlow.js for browser-based ML
● Flexibility: ○ TensorFlow Lite for mobile and edge devices
○ Supports multiple programming languages (Python,
JavaScript, C++, etc.) ● Ease of Use:
○ Works on various platforms (desktop, mobile, web, ○ High-level APIs like Keras for rapid prototyping
cloud) ○ TensorFlow Hub for pre-trained models and components
○ Allows for custom model architecture and training ○ TensorBoard for visualization and debugging
loops
Use Cases and Applications

● Computer Vision: ● Generative Models:

○ Image classification ○ Image generation (GANs)
○ Object detection ○ Text generation
○ Facial recognition ● Reinforcement Learning:
● Natural Language Processing: ○ Game AI
○ Text classification ○ Robotics control
○ Language translation ● Time Series Analysis:
○ Sentiment analysis ○ Stock price prediction
● Speech Recognition: ○ Weather forecasting
○ Voice-to-text conversion ● Recommendation Systems:
○ Speaker identification ○ Product recommendations
○ Content personalization
What is Data flow graphs?
● A data flow graph is a way of representing Benefits of Data Flow Graphs
computations in terms of a graph where:
● Parallelism: Since the graph defines independent
○ Nodes represent operations (e.g., addition, operations, TensorFlow can execute them in parallel,
multiplication). utilizing multiple CPUs, GPUs, or TPUs efficiently.
● Distribution: The graph can be split across multiple
○ Edges represent the data (tensors) that devices or machines, enabling distributed computing.
flow between these operations. ● Optimization: TensorFlow can analyze the graph and
optimize it by fusing operations, eliminating redundancy,
How TensorFlow Uses Data Flow Graphs and reducing memory usage.
● Visualization: The structure of the graph can be visualized
● TensorFlow builds a computational graph that
using tools like TensorBoard, making it easier to understand
defines the structure of the computation.
and debug the computation.
● Operations are nodes, and the data (tensors) flow
between these operations through edges.
● The graph is constructed before the computation
is executed, allowing TensorFlow to optimize the We will discuss this
entire computation.
more in later slides
 Example: Simple Data Flow Graph

Imagine we want to compute the expression

Z = (x+y) x w

● Step 1: Define the nodes.

○ Node 1: Add operation to compute x+y.
○ Node 2: Multiply operation to compute
(x+y)×w.

● Step 2: Define the edges.

○ Edge 1: Carries the result of x+y to the
multiply node.
○ Edge 2: Carries the value of w to the
multiply node. Nodes: tf.add and tf.multiply are the nodes.
Edges: The constants x, y, and w, and the intermediate result
Tools like TensorBoard allow you to visualize the from tf.add to tf.multiply.
computation graph, showing the nodes and edges,
making it easier to understand the flow of data and
operations.
Basic operations in
TensorFlow
a) Tensor Creation:

● tf.constant(): Create constant tensors TensorFlow 2.x Behavior

Syntax: tf.constant(value, dtype=None,
In TensorFlow 2.x, eager execution is
shape=None, name='Const')
enabled by default, which means operations
● are evaluated immediately as they are called
tf.Variable(): Create mutable tensors that can be
from Python. This makes it easier to work
updated during training therefore used for the
with and debug. You can directly print the
model parameters.
values of the tensors using .numpy()
Syntax: tf.Variable(initial_value, name=None,
method to convert them to numpy arrays.
dtype=None)

● tf.zeros(), tf.ones(): Create tensors filled with 0s or

1s

● tf.random.normal(): Create tensors with random

values drawn from a normal distribution.
b) Mathematical Operations:

● Addition: tf.add() or '+'

● Subtraction: tf.subtract() or '-'

● Multiplication: tf.multiply() or '*'

● Division: tf.divide() or '/'

● Matrix multiplication: tf.matmul()

c) Tensor Manipulation:

● Reshaping: tf.reshape()

● Transposing: tf.transpose()

● Concatenation: tf.concat()

● Slicing: tensor[start:end]
TensorFlow Data Types
a) Numeric Types:

● tf.float32, tf.float64: Floating-point numbers

● tf.int8, tf.int16, tf.int32, tf.int64: Signed integers
● tf.uint8, tf.uint16: Unsigned integers
● tf.bool: Boolean values

b) String Type:

● tf.string: For text data

c) Complex Number Types:

● tf.complex64, tf.complex128: Complex numbers

d) Quantized Types: Key Point: Choosing the right data type is

crucial for model efficiency and accuracy.
● tf.qint8, tf.quint8, tf.qint32: For quantized operations
This code demonstrates how to create tensors with different data types in TensorFlow.
Each tensor is created using tf.constant() with the appropriate dtype parameter.

For the quantized types, we use tf.quantization.quantize() to create quantized

tensors from floating-point values. These are typically used in specific contexts where
memory efficiency or hardware compatibility requires quantized representations.
Creating and manipulating matrices in
TensorFlow Explanation:

● Creating Matrices: Define

matrices using tf.constant().
● Matrix Addition: Use tf.add()
or the + operator.
● Element-wise Multiplication:
Use tf.multiply() or the *
operator.
● Matrix Multiplication (Dot
Product): Use tf.matmul().
● Matrix Transpose: Use
tf.transpose().
Defining Operations in TensorFlow

● Defining a Simple Function: Use standard Python

function definition to create operations. In
TensorFlow 2.x, these are executed eagerly by
default.

● Using tf.function for Performance

Optimization:
○ Decorate functions with @tf.function to
compile them into a static graph for faster
execution.
○ tf.function improves performance by
optimizing and parallelizing the execution of
operations.
Now you might be wondering
what is static graph?
Computational Graph
A computational graph is a directed graph where the nodes represent operations or variables, and the edges represent the
flow of data between operations. In the context of deep learning frameworks, it's a way to represent and organize the series of
operations that comprise a model or computation.
Which is Better?

● Static Graphs: Better for performance-critical applications and production environments

where the same operations are performed repeatedly. They benefit from optimizations and
can be more efficient.
● Dynamic Graphs: Better for research, experimentation, and development phases due to
their ease of use and flexibility. They allow for immediate feedback and simpler debugging.
Example: Using @tf.function to Create a Static Graph

Here’s how you can define operations with both dynamic and static graph execution in TensorFlow 2.x:

Explanation:

● Eager Execution: The simple_operation function

executes immediately, providing immediate results.
● Static Graph Execution: The optimized_operation
function, decorated with @tf.function, compiles into a
static graph. TensorFlow optimizes this graph, potentially
improving performance during repeated execution.

Conclusion:

● Use dynamic graphs (eager execution) for

development, debugging, and models requiring dynamic
computation.
● Use static graphs (compiled with @tf.function) for
performance-critical applications and deployment.
Creating Complex Operations by Nesting
Functions Explanation:

● Nested Functions: Create reusable operations

by nesting functions.
● Higher-Level Functions: Organize code by
using higher-level functions that call nested
functions.

Best Practices for Organizing Code:

● Modularity: Break down complex operations into

smaller, reusable functions.
● Readability: Use meaningful function names
and comments to improve code readability.
● Maintainability: Organize functions logically to
make the code easier to maintain and extend.
Activation Functions
Activation functions are mathematical functions used in neural networks to introduce non-
linearity into the model. They are a critical component because they enable neural networks to
learn and represent complex patterns. Without activation functions, a neural network would
simply be a linear regression model, regardless of the number of layers.

Purpose of Activation Functions:

1. Introduce Non-Linearity: Activation functions allow the network to learn non-linear

mappings between inputs and outputs, which is essential for tackling complex tasks
such as image recognition, natural language processing, and more.

2. Enable Learning of Complex Patterns: By transforming the input data in non-linear

ways, activation functions enable neural networks to capture intricate patterns and
relationships.

3. Control Output Range: Activation functions can squash the output to a specific
range, making it easier to handle and interpret, especially in tasks like classification.
Types of Activation Functions:

Linear Activation Function: ● ReLU (Rectified Linear Unit):

○ Definition:
● Linear
○ Definition: f(x)=x ○ Range: [0, ∞)
○ Use: Rarely used because it does not introduce non- ○ Use: Widely used in hidden layers due to
linearity. its efficiency and ability to mitigate the
vanishing gradient problem.
Non-Linear Activation Functions: ● Softmax:
○ Definition:
● Sigmoid:
○ Definition: ○ Range: (0, 1) for each output, sum to 1
○ Use: Used in the output layer of multi-class
○ Range: (0, 1) classification problems to produce
○ Use: Often used in the output layer for binary classification. probabilities.

● Tanh (Hyperbolic Tangent):

○ Definition:
There are various other variants
of ReLu and other functions
○ Range: (-1, 1) available which are out of scope
○ Use: Common in hidden layers, where zero-centered output of this lecture
is beneficial.
Let’s take these 3 of them and apply it using
tensorflow

● ReLU: tf.nn.relu()

● Sigmoid: tf.nn.sigmoid()

● Tanh: tf.nn.tanh()

● Softmax: tf.nn.softmax()

Softma
x
Building Neural Networks with Multiple
Layers

Explanation:

● Sequential API: Use tf.keras.Sequential to stack layers in a linear manner. This API is simple and straightforward,
making it easy to build models by specifying a list of layers.
● Dense Layers: Define fully connected layers with tf.keras.layers.Dense. Each Dense layer specifies the number of
neurons and the activation function.
Explanation:

● Layer Management: Add layers incrementally to a tf.keras.Sequential model. This approach provides more control
and flexibility, allowing you to modify the model structure more dynamically.
● Model Summary: Use model.summary() to display the model architecture and parameters. The output will be the
same as in the first example, but the layers are added one at a time.
Working with Multiple Layers:

● Building Neural Networks: Use tf.keras.Sequential to build neural networks with multiple layers. This API
simplifies the process by allowing you to specify layers in a list or add them incrementally.
● Layer Management: Incrementally adding layers can provide more flexibility and control over the model
structure. It is useful when you need to dynamically change the model architecture.
Implementing Loss Functions
Mean Squared Error (MSE): Measures the average squared difference between the predicted and actual
values.

In this example, the small difference between predicted and true

values results in a small loss value.
Categorical Cross-Entropy: Measures the difference between two probability distributions for
classification tasks.

The example shows the loss for two samples, each belonging to different
classes.
Custom Loss Functions: Define a custom loss function by creating a function that takes true labels and
predictions as input and returns a scalar loss value.

The custom loss function calculates the Mean Absolute Error (MAE) between the predicted and true
values. The output shows the average absolute difference between the predicted and true values.
Understanding Backpropagation

Backpropagation: A method used to calculate the

gradient of the loss function with respect to the model
parameters. It helps update the model weights to
minimize the loss.
Process:

1. Forward Pass: Compute the output and the loss.

2. Backward Pass: Compute the gradient of the loss

with respect to each parameter.

3. Parameter Update: Update the parameters using

the gradients.
Let’s Understand it step by step

Neural network training is about finding weights that minimize prediction error. We usually start our training with a

set of randomly generated weights.Then, backpropagation is used to update the weights in an attempt to correctly

map arbitrary inputs to outputs.

Our initial weights will be as following: w1 = 0.11, w2 = 0.21, w3 = 0.12, w4 = 0.08, w5 = 0.14 and w6 = 0.15

Weights
Our dataset has one sample with two inputs and one output.

Our single sample is as following inputs=[2, 3] and output=[1].

Dataset
We will use given weights and inputs to predict the output. Inputs are multiplied by weights; the

results are then passed forward to next layer.

Forward Pass
Now, it’s time to find out how our network performed by calculating the difference between the
actual output and predicted one. It’s clear that our network output, or prediction, is not even close
to actual output. We can calculate the difference or the error as following.

Calculating
Error
Our main goal of the training is to reduce the error or the difference between prediction and actual

output. Since actual output is constant, “not changing”, the only way to reduce the error is to

change prediction value. The question now is, how to change prediction value?

By decomposing prediction into its basic elements we can find that weights are the variable

elements affecting prediction value. In other words, in order to change prediction value, we need to

change weights values.

Reducing Error
The question now is how to change\update the weights
value so that the error is reduced?
The question now is how to change\update the weights
value so that the error is reduced?

The answer is Backpropagation!

Backpropagation, short for “backward propagation of errors”, is a mechanism used to
update the weights using gradient descent. It calculates the gradient of the error
function with respect to the neural network’s weights. The calculation proceeds
backwards through the network.
Gradient descent is an iterative optimization algorithm for finding the minimum of a
function; in our case we want to minimize th error function. To find a local minimum of
a function using gradient descent, one takes steps proportional to the negative of the
gradient of the function at the current point.
For example, to update w6, we take the current w6 and subtract the partial
derivative of error function with respect to w6. Optionally, we multiply the
derivative of the error function by a selected number to make sure that the new
updated weight is minimizing the error function; this number is called learning rate.
The derivation of the error function is evaluated by
applying the chain rule as following
So to update w6 we can apply the following formula

Similarly, we can derive the update formula for w5 and any other weights existing
between the output and the hidden layer
However, when moving backward to update w1, w2, w3 and w4 existing between input
and hidden layer, the partial derivative for the error function with respect to w1, for
example, will be as following.
We can find the update formula for the remaining weights w2, w3 and w4 in the same way.

In summary, the update formulas for all weights will be as following:

We can rewrite the update formulas in matrices as following

Using derived formulas we can find the new weights

Learning rate: is a hyperparameter which means that we need to manually guess its value.
Now, using the new weights we will repeat the forward passed

Backward Pass

We can notice that the prediction 0.26 is a little bit closer to actual
output than the previously predicted one 0.191. We can repeat the same
process of backward and forward pass until error is close or equal to
zero.
Stochastic and Mini-Batch Gradient
Descent
Stochastic Gradient Descent (SGD): Mini-Batch Gradient Descent:

● Definition: Uses a single training example per iteration to ● Definition: Uses a small random subset (mini-batch) of training
update the parameters. examples per iteration.
● Example: ● Example:

○ Each iteration updates the parameters based on ○ Each iteration updates the parameters based on the
one randomly chosen training example (x(i),y(i)). average gradient of the mini-batch.
● Advantages: ● Advantages:
○ Faster convergence for large datasets. ○ Balances the efficiency of batch gradient descent and
○ Allows for real-time or online learning. the speed of SGD.
● Disadvantages: ○ Reduces the noise in parameter updates compared to
○ More noise in updates, leading to higher variance SGD.
in the parameter updates. ● Disadvantages:
● Use Case: Suitable for online learning and large datasets ○ Requires careful tuning of the mini-batch size.
where the full dataset cannot fit into memory. ● Use Case: Commonly used in practice due to a good balance
between performance and computational efficiency.
Implementing batch and stochastic
training in TensorFlow

https://colab.research.google.com/drive/1584uILesPmhe9
Eh6kd7wnnj3CrLMSVHr?usp=sharing
Model Evaluation Metrics
Common Model Evaluation Metrics:

1. Accuracy:
○ Measures the proportion of correctly classified instances out of all
instances.
○ Suitable for balanced datasets.

2. Precision:
○ Measures the proportion of true positive predictions (correctly predicted
positive instances) among all positive predictions.
○ Helps in understanding the reliability of positive predictions.

3. Recall (Sensitivity):
○ Measures the proportion of true positive predictions among all actual
positive instances in the dataset.
○ Indicates how well the model captures positive instances.

4. F1 Score:
○ Harmonic mean of precision and recall. Provides a balance between
precision and recall.
○ Useful when there is an uneven class distribution.
Accuracy Precision
Recall
● What it means: How many total ● What it means: Of all the times the
● What it means: Of all the actual
predictions were correct (both model said “yes” (positive), how many
positives, how many did the model
positives and negatives). were actually correct.
● ● correctly identify.
Use it when: The data is balanced Use it when: False positives are
● Use it when: Missing positives is
(equal positives and negatives). costly.
● ● costly.
Example: If you have a model Example: In spam detection, if
● Example: In disease detection, you
predicting whether an email is spam, marking a good email as spam (false
don’t want to miss a positive case
and there are roughly equal spam positive) is a big problem, you want
(false negative), so high recall is
and non-spam emails, accuracy is a high precision. This means fewer
important to ensure most sick
good measure. non-spam emails are misclassified.
patients are identified.

F1-Score

● What it means: A balance between precision and recall.

● Use it when: The data is imbalanced, or both false positives and false
negatives matter.
● Example: In fraud detection, where you want to catch fraud (recall) but also
avoid wrongly accusing too many people (precision), F1-score balances both.
Explanation:

● Accuracy, Precision, Recall: These

metrics help evaluate the
performance of classification models
based on different aspects of
prediction correctness.

● TensorFlow Metrics: Use

tf.keras.metrics to compute
evaluation metrics directly from
TensorFlow tensors. These metrics
update state based on predictions
and true labels, and result() fetches
the computed metric value.
Importance of Unit Tests

Unit tests are crucial in software development, including TensorFlow code, for several reasons:

1. Verification of Functionality: Unit tests verify that individual units (functions, methods, or classes) of your code behave as
expected. In TensorFlow, this could mean checking that specific layers, models, or operations produce correct outputs for
given inputs.

2. Early Detection of Bugs: Writing tests helps catch bugs early in the development process, making debugging easier and
reducing the likelihood of encountering issues later on.

3. Maintainability: Tests serve as documentation and specification for your code. They make it easier for new developers to
understand the expected behavior of functions or modules without needing to delve into the implementation details.

4. Refactoring Confidence: When refactoring or modifying existing code, unit tests ensure that changes do not break
existing functionality. They act as a safety net, providing confidence that the system still works correctly after modifications.

5. Regression Testing: Unit tests form the basis for regression testing, ensuring that previously fixed bugs do not reappear
in subsequent versions of your code.
How to write Unit Tests?

2. Write Your TensorFlow Code

1. Setup Your Environment
Create your TensorFlow model or function that you
want to test. Here's a simple example of defining and
Ensure TensorFlow and any necessary dependencies
compiling a neural network model:
are installed in your development environment.
3. Write Unit Tests Using unittest
or pytest

Use a testing framework like unittest

or pytest to create unit tests for your
TensorFlow code. Here’s an example
using unittest:

4. Running Unit Tests

Run your unit tests to verify that your

TensorFlow code behaves as expected:
Tips for Writing Effective Unit Tests

● Isolate Tests: Ensure each test is independent and does not rely on the
state of other tests.
● Use Mocking: When testing TensorFlow models, you may need to mock
data or model inputs to simulate different scenarios.
● Coverage: Aim to cover edge cases and different inputs to ensure
robustness.
● Readable Assertions: Use meaningful assertions (assertEqual,
assertGreater, assertLess, etc.) to clearly define expected outcomes.
● Continuous Integration: Integrate unit tests into your development
workflow (e.g., using CI/CD tools) to automate testing and catch issues
early.
Multiple Executors for Distributed Training in
TensorFlow
Distributed training in TensorFlow allows you to leverage multiple GPUs, TPUs, or machines to train large
models faster and more efficiently. TensorFlow supports various distributed training strategies, including
MirroredStrategy, MultiWorkerMirroredStrategy, and TPUStrategy.
Mirrored Strategy

● Suitable for single-machine, multi-GPU training.

● Replicates the model on each GPU and synchronizes updates.

Multi Worker Mirrored Strategy

● Suitable for multi-machine, multi-GPU training.

● Each worker (machine) computes gradients on its local batch and then
synchronizes these gradients with other workers.
TPU Strategy

● Suitable for training on Tensor Processing Units (TPUs).

● Provides efficient distribution of computations across TPU cores

Best Practices

● Data Sharding: Ensure that your data is evenly distributed across the devices to avoid bottlenecks.

● Batch Size: Use a larger batch size to fully utilize the computational resources.

● Synchronization: Properly synchronize the updates across devices to ensure model consistency.

● Checkpointing: Regularly save checkpoints to avoid losing progress in case of failures.

● Monitoring: Use TensorBoard to monitor the training process and adjust parameters as necessary.
Best Practices for Deploying TensorFlow Models
Optimizing a model involves several techniques aimed at reducing its size and improving its
inference speed. Here, we'll cover three key methods: quantization, pruning, and model
compression. Below is an example using TensorFlow.

Quantization

Quantization reduces the precision of the

numbers used to represent your model’s
parameters, typically from 32-bit floating-
point to 8-bit integers. This reduces model
size and improves inference speed without
significant loss in accuracy.
Pruning

Pruning involves removing weights that

contribute less to the overall performance of
the model. This reduces the model size and
can also improve inference speed.
Model Compression

Model compression tools, such as

TensorFlow Model Optimization Toolkit,
provide a set of APIs to help compress
models. This can involve both quantization
and pruning, among other techniques.
TensorFlow serving using Docker
TensorFlow Serving is a flexible, high-performance serving system for machine
learning models designed for production environments.

Install TensorFlow Serving: Request Predictions:

Serve the Model:

https://www.tensorflow.org/tfx/serving/docker
https://github.com/nfmcclure/tensorflow_cookbook/tree/master
Productionising the Tensorflow models
Productionizing TensorFlow models for deployment in real-world applications involves transforming a
trained model into a fully operational service or application that can handle real-time data, scale, and
provide predictions or insights. This process typically includes several stages, from model preparation to
deployment, monitoring, and maintenance. Here's a breakdown of the key steps involved:

1. Model Development and Training

● Data Preparation: Clean, preprocess, and engineer features from your data.
● Model Selection: Use TensorFlow to build and train the machine learning (ML) or deep learning (DL) model.
Common model types include neural networks, CNNs (for images), RNNs (for sequential data), etc.
● Model Evaluation: Evaluate the model's performance on a test set using appropriate metrics (accuracy, loss,
precision, recall, etc.).
● Save Model: Once satisfied with the model, save it using TensorFlow's SavedModel format. This is a
universal format that saves both the architecture and weights for later use.
2. Model Optimization

● Pruning & Quantization: Optimize the model to reduce size and improve
inference speed, especially for deployment on mobile or edge devices.
TensorFlow Lite provides tools for this:

○ Pruning: Reduces the number of weights.

○ Quantization: Converts the model from floating-point to lower
precision (e.g., INT8).
● Batching: Handle multiple requests at once (batch processing), which can
improve efficiency when serving the model in production.
3. Model Packaging

● Dockerization: To make the deployment process consistent and reproducible,

package your model in a Docker container. Docker allows you to bundle the
application, TensorFlow, and any necessary dependencies into a container that can
run anywhere.

○ Create a Dockerfile to define your environment and steps to run the model.

● APIs for Serving: You can use TensorFlow Serving to serve the model as an API
that can handle REST or gRPC requests. TensorFlow Serving is designed for
scalable and high-performance model serving.

● Install TensorFlow Serving and expose an API.

4. Model Deployment

There are several deployment options

depending on the type of application and
infrastructure:

a. Cloud Deployment

● AWS (SageMaker): AWS SageMaker

allows you to train, tune, and deploy
models at scale. You can easily
deploy TensorFlow models using
SageMaker's managed services.
5. Scaling and Monitoring

● Horizontal Scaling: As demand grows, you may need to scale the service to handle more
requests. This can be done using container orchestration tools like Kubernetes, or cloud
services such as AWS Elastic Beanstalk or Google Kubernetes Engine.

● Load Balancing: Implement load balancers to distribute incoming requests evenly across
multiple instances of your model service.

● Monitoring: Use monitoring tools such as Prometheus, Grafana, or cloud-native solutions

(e.g., AWS CloudWatch, Google Stackdriver) to track metrics like latency, request volume,
and error rates.
● Model Monitoring: Monitor the performance of your model over time to detect drift or
degradation. You can log prediction accuracy, latency, and other statistics.
6. Continuous Integration and Continuous 7. Post-Deployment Monitoring and
Deployment (CI/CD) Maintenance

● Automation: Set up CI/CD pipelines to ● Model Drift Monitoring: Over time, the
automate the process of deploying updated model's performance may degrade due to
models. Whenever a new model version is changes in real-world data (data drift). You
trained, the pipeline will automatically package, should monitor this and retrain the model when
test, and deploy the model. necessary.
○ GitLab CI, Jenkins, CircleCI: These
tools can automate model deployment ● Retraining: Set up pipelines for continuous
steps after successful training and retraining of the model using new data,
evaluation. ensuring that the model stays up-to-date.

● A/B Testing: Deploy multiple versions of your ● Logging: Ensure that logs are maintained for
model (e.g., old and new) and split the incoming all predictions made by the model. This helps in
traffic between them to see which version auditing and improving the model.
performs better in production.
Key Components

1. Model Development: Train and save using TensorFlow.

2. Optimization: Prune, quantize, or batch for efficient performance.
3. Packaging: Use Docker, TensorFlow Serving, or TensorFlow Lite.
4. Deployment: Deploy using cloud (AWS, Google Cloud, Azure) or mobile
(TensorFlow Lite, TensorFlow.js).
5. Scaling: Scale with Kubernetes or cloud services.
6. Monitoring: Track performance using tools like Prometheus or CloudWatch.
7. Automation: Use CI/CD pipelines for automated deployment and testing.

This process ensures that TensorFlow models are effectively integrated into real-world
applications, able to scale, and monitored for long-term performance.