[AI from Scratch] Episode 226: Introduction to TensorFlow — Basics of the Deep Learning Framework

Recap and Today’s Theme

Hello! In the previous episode, we used Python’s Keras library to build a basic neural network for classifying handwritten digits. Keras provides a simple API, making it an excellent tool for beginners to create models easily.

This time, we will introduce TensorFlow, the deep learning framework that also powers Keras as its backend. Developed by Google, TensorFlow is an open-source framework designed for building, training, and deploying deep learning and machine learning models. With TensorFlow, you can design and customize complex neural networks. Let’s learn the basics of TensorFlow and how to use it!

What Is TensorFlow?

TensorFlow is an open-source deep learning framework developed by Google. It offers powerful tools for efficiently building, training, and deploying deep learning models. TensorFlow shines when handling large datasets and advanced models.

Key Features of TensorFlow

1. Scalability: Supports GPU and TPU acceleration for fast training and inference.
2. Flexibility: Integrates with Keras, allowing both easy-to-use APIs for beginners and advanced customization for more complex models.
3. Open-Source Ecosystem: Includes tools like TensorFlow Hub and TensorFlow Extended (TFX), providing a comprehensive development environment.

Installing and Using TensorFlow

1. Installing TensorFlow

To install TensorFlow, run the following command:

pip install tensorflow

2. Importing TensorFlow

After installation, import TensorFlow in your Python environment:

import tensorflow as tf

By importing TensorFlow, you gain access to the tools needed for neural network construction and numerical computation.

Basics of TensorFlow

TensorFlow is built around the concepts of Tensors and Graphs.

• Tensor: A tensor is a multi-dimensional array, serving as the fundamental data structure in TensorFlow. Scalars, vectors, and matrices are all treated as tensors.
• Graph: A graph connects tensors and operations, efficiently managing computations in TensorFlow.

3. Creating Tensors

Let’s explore how to create tensors in TensorFlow:

# Scalar tensor
scalar = tf.constant(7)
print(scalar)

# Vector tensor
vector = tf.constant([1, 2, 3])
print(vector)

# Matrix tensor
matrix = tf.constant([[1, 2], [3, 4]])
print(matrix)

# 3D tensor
tensor3d = tf.constant([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(tensor3d)

• tf.constant(): Creates a tensor with specified values.

4. Performing Tensor Operations

TensorFlow simplifies tensor operations:

# Adding tensors
a = tf.constant([1, 2, 3])
b = tf.constant([4, 5, 6])
c = tf.add(a, b)
print(c)

# Multiplying tensors
d = tf.multiply(a, b)
print(d)

# Matrix multiplication
e = tf.matmul(tf.constant([[1, 2]]), tf.constant([[3], [4]]))
print(e)

• tf.add(): Adds tensors.
• tf.multiply(): Element-wise multiplication.
• tf.matmul(): Matrix multiplication.

Building a Simple Neural Network

Using TensorFlow, let’s build a simple neural network model. We will use Keras, integrated with TensorFlow, to classify the MNIST dataset of handwritten digits.

1. Loading the Dataset

The MNIST dataset is built into Keras and can be easily loaded:

# Loading the dataset
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Normalizing data (scaling pixel values from 0-255 to 0-1)
x_train = x_train.astype("float32") / 255
x_test = x_test.astype("float32") / 255

# Reshaping images to 1D (28x28 -> 784)
x_train = x_train.reshape((-1, 784))
x_test = x_test.reshape((-1, 784))

2. Building the Model

Using Keras’s API, we build a simple neural network:

# Defining the model
model = tf.keras.Sequential([
    tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
    tf.keras.layers.Dense(64, activation='relu'),
    tf.keras.layers.Dense(10, activation='softmax')
])

• tf.keras.Sequential: Stacks layers sequentially.
• Dense: Adds a fully connected layer, specifying the number of neurons and activation function.

3. Compiling the Model

Compile the model by setting the loss function, optimizer, and evaluation metrics:

model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

• optimizer=’adam’: An efficient optimizer for training.
• loss=’sparse_categorical_crossentropy’: Suitable for multi-class classification.
• metrics=[‘accuracy’]: Evaluates model performance based on accuracy.

4. Training the Model

# Training the model
model.fit(x_train, y_train, epochs=10, batch_size=32, validation_split=0.2)

• epochs=10: Iterates over the dataset 10 times.
• batch_size=32: Number of samples per gradient update.
• validation_split=0.2: Uses 20% of the training data for validation.

5. Evaluating the Model

Evaluate the model’s accuracy using the test data:

test_loss, test_accuracy = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_accuracy:.2f}")

6. Making Predictions

Use the trained model to predict test data outcomes:

predictions = model.predict(x_test)

# Displaying the first 5 predictions
for i in range(5):
    print(f"Actual: {y_test[i]}, Predicted: {np.argmax(predictions[i])}")

Summary

This episode covered the basics of TensorFlow, demonstrating how to build a simple neural network. TensorFlow offers great flexibility and, when combined with Keras, enables easy construction of deep learning models. Understanding the fundamentals of TensorFlow sets the stage for building more complex models and implementing advanced algorithms.

Next Episode Preview

Next time, we will delve deeper into building models with Keras, exploring its high-level API to create more advanced and flexible neural networks. Stay tuned!

---

Annotations

• Tensor: The basic data structure in TensorFlow, representing multi-dimensional arrays.
• Keras: A high-level API integrated with TensorFlow, simplifying the creation and training of neural networks.