TensorFlow API

TensorFlow API is a collection of machine learning libraries developed by Google. It enables building, training, and deploying Machine Learning models. TensorFlow API is built to work across multiple platforms like CPUs, GPUs, TPUs, and mobile devices. It provides both high-level and low-level APIs for model development as well as model deployment.

High-level APIs

High-level APIs provide a framework for easy development and training of Machine Learning models. The following are some of the High-level API modules available in TensorFlow.

Keras API

Keras is a user-friendly high-level API that enables the development of complex deep learning models with just a few lines of code. Keras provides pre-built models like Convolutional Neural Networks (CNN) and Recurrent Neural Networks (RNN) that can be easily used for image recognition or Natural Language Processing (NLP) tasks.

import tensorflow as tf
from tensorflow import keras

# load the MNIST dataset using keras API
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# normalize the pixel values to be between 0 and 1
train_images = train_images / 255.0
test_images = test_images / 255.0

# define a simple fully connected neural network
model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

# compile the model with loss function, optimizer and evaluation metric
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# train the model for a given number of epochs
model.fit(train_images, train_labels, epochs=10)

# evaluate the model accuracy on the test dataset
test_loss, test_acc = model.evaluate(test_images, test_labels)

print('Test accuracy:', test_acc)

Estimators API

Estimators API is used for the development of large-scale, high-performance Machine Learning models. It enables the easy deployment of Machine Learning models to distributed environments like Cloud Platform or on-premises.

import tensorflow as tf
import pandas as pd
import numpy as np

# define input function for the estimator model
def input_fn(features, labels, training=True, batch_size=256):
    dataset = tf.data.Dataset.from_tensor_slices((dict(features), labels))
    if training:
        dataset = dataset.shuffle(1000).repeat()
    return dataset.batch(batch_size)

# define feature columns for the input data
feature_columns = []
for key in df.keys():
    feature_columns.append(tf.feature_column.numeric_column(key=key))

# define the estimator model
estimator = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[128, 64, 32],
    n_classes=3
)

# train the estimator model
estimator.train(
    input_fn=lambda: input_fn(train_x, train_y),
    steps=5000
)

# evaluate the estimator model
eval_result = estimator.evaluate(
    input_fn=lambda: input_fn(test_x, test_y, training=False)
)
print('Test set accuracy:', eval_result['accuracy'])

Low-level APIs

Low-level APIs provide finer control over the development of Machine Learning models. Some of the Low-level API modules available in TensorFlow are:

TensorFlow Core

TensorFlow Core is the fundamental Low-level API used for Machine Learning model development. It provides a computational graph that enables the easy execution of numerical computations on CPU, GPU, or TPU.

import tensorflow as tf

# define constant tensors using TensorFlow Core
a = tf.constant(4.0, dtype=tf.float32)
b = tf.constant(3.0, dtype=tf.float32)
c = tf.constant(2.0, dtype=tf.float32)

# define operations using TensorFlow Core
d = tf.multiply(a, b)
e = tf.add(c, d)
f = tf.subtract(b, 1.0)

# execute the computational graph and print the result
output = tf.divide(e, f)
print(output.numpy())

TF.Data API

TF.Data API is used for the efficient reading and transformation of data for Machine Learning models. It enables the easy manipulation of data from different sources in batches or parallel settings.

import tensorflow as tf

# define input data pipeline using TF.Data API
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset = dataset.shuffle(10000).batch(32)

# define custom data transformations using TF.Data API
def augment_data(image, label):
    image = tf.image.random_flip_left_right(image)
    image = tf.image.random_brightness(image, max_delta=0.1)
    return image, label

# apply custom data transformation to the input data pipeline
dataset = dataset.map(augment_data)

Conclusion

TensorFlow API is a powerful set of libraries for Machine Learning model development and deployment. It provides both High-level and Low-level API modules that enable the easy development of complex models as well as finer control over the development process. TensorFlow API is constantly evolving, and new features are being added to make Machine Learning more accessible to everyone.