TensorFlow & Keras Basics

1. What are TensorFlow and Keras?

TensorFlow is an open-source library developed by Google for numerical computation and large-scale machine learning. It provides a comprehensive ecosystem for building and deploying ML models.

Keras is a high-level API that runs on top of TensorFlow (and other backends). It's designed to be user-friendly, modular, and extensible, making it excellent for rapid prototyping and experimentation with neural networks.

2. Installation

Before we start coding, ensure you have Python installed. Then, you can install TensorFlow and Keras using pip:

pip install tensorflow

Keras is now integrated directly into TensorFlow, so installing TensorFlow typically includes Keras.

3. Building Your First Neural Network

Let's create a simple sequential model. A sequential model is a linear stack of layers.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

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

print("Model created successfully!")
model.summary()
                

In this example:

• layers.Dense creates a fully connected layer.
• 64 is the number of neurons in the layer.
• activation='relu' uses the Rectified Linear Unit activation function.
• input_shape=(784,) specifies the shape of the input data (e.g., flattened 28x28 images).
• The final layer has 10 neurons with a softmax activation, suitable for multi-class classification.

4. Compiling the Model

Before training, we need to configure the learning process. This is done via the compile method:

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

print("Model compiled successfully!")
                

• optimizer: The algorithm used to update the weights (e.g., 'adam', 'sgd').
• loss: The objective function to minimize (e.g., 'sparse_categorical_crossentropy' for classification).
• metrics: Used to monitor training and testing steps (e.g., 'accuracy').

5. Training the Model (Conceptual)

Training involves feeding your data to the model to learn patterns. You'll typically need labeled data (features and their corresponding labels).

Here's a conceptual example using dummy data:

# Assume you have numpy arrays for training data and labels
# For example, x_train and y_train

# Dummy data for demonstration
import numpy as np
x_train = np.random.rand(1000, 784)
y_train = np.random.randint(0, 10, 1000)

# Train the model
history = model.fit(x_train, y_train, epochs=10, validation_split=0.2)

print("Model training completed (with dummy data)!")
                

• epochs: The number of times the model will go through the entire training dataset.
• validation_split: A fraction of the training data to be used as validation data.

6. Evaluating and Making Predictions

After training, you can evaluate the model's performance on unseen data and make predictions.

# Assume you have test data x_test and labels y_test

# Dummy test data
x_test = np.random.rand(100, 784)
y_test = np.random.randint(0, 10, 100)

# Evaluate the model
loss, accuracy = model.evaluate(x_test, y_test, verbose=0)
print(f"Test Loss: {loss:.4f}")
print(f"Test Accuracy: {accuracy:.4f}")

# Make predictions
predictions = model.predict(x_test)
print(f"Sample predictions shape: {predictions.shape}")
print(f"First prediction (probabilities): {predictions[0]}")
print(f"Predicted class for first sample: {np.argmax(predictions[0])}")