Visualization and Tuning

🔭 Training and Evaluation: Visualization and Tuning

The Story of the Kitchen That Watches Itself

Imagine you’re baking a cake, but you can’t see inside the oven. You don’t know if it’s rising perfectly or burning! That would be scary, right?

TensorBoard is like a magical window into your AI’s oven. You can watch your model learn in real-time—seeing if it’s getting smarter or making mistakes.

And Keras Tuner? That’s like having a helpful assistant who tries different recipes automatically to find the BEST one for you!

Let’s explore these amazing tools together! 🎂

🔧 TensorBoard Setup

What is TensorBoard?

TensorBoard is your AI’s report card viewer. Just like teachers write grades so parents can see how kids are doing, TensorBoard shows you how your AI is doing during training.

Think of it Like This:

You’re training a puppy 🐕. You want to know:

• Is the puppy learning to sit faster today?
• Are treats working better than praise?
• When did the puppy learn the trick?

TensorBoard answers ALL these questions for your AI!

Setting Up TensorBoard

It’s super easy—just 3 steps:

# Step 1: Import TensorBoard
import tensorflow as tf

# Step 2: Create a log folder
log_dir = "logs/my_experiment"

# Step 3: Add the callback
tensorboard_callback = tf.keras.callbacks.TensorBoard(
    log_dir=log_dir,
    histogram_freq=1
)

Running TensorBoard

After training, open your terminal and type:

tensorboard --logdir logs/my_experiment

Then open your browser to http://localhost:6006 and BOOM! 🎆 You see everything!

graph TD
    A["Train Model"] --> B["Write Logs"]
    B --> C["TensorBoard Reads Logs"]
    C --> D["Beautiful Graphs! 📊"]

📝 TensorBoard Logging

What Gets Logged?

TensorBoard can record many things—like a diary for your AI:

Simple Logging Example

# Training with TensorBoard logging
model.fit(
    x_train, y_train,
    epochs=10,
    validation_data=(x_val, y_val),
    callbacks=[tensorboard_callback]
)

Every time your model finishes an epoch (one full round of training), TensorBoard writes notes about how it did!

Custom Logging

Want to log something special? Easy!

# Create a file writer
writer = tf.summary.create_file_writer(log_dir)

# Log your custom values
with writer.as_default():
    tf.summary.scalar("my_metric", 0.95, step=1)
    tf.summary.image("sample_image", img, step=1)

Think of this like writing your own notes in the diary! 📓

🎨 TensorBoard Features

The Dashboard Magic ✨

TensorBoard isn’t just one tool—it’s a whole toolbox of amazing features!

1. Scalars Tab 📈

See numbers over time. Like watching:

• Your grade going from C to A
• Your video game score improving
• Your model’s accuracy climbing!

2. Graphs Tab 🕸️

See your model’s brain structure. Every layer, every connection—like an X-ray of your AI!

3. Histograms Tab 📊

Watch how the model’s weights change. Are they healthy? Are they stuck? The histogram tells all!

4. Images Tab 🖼️

If your model works with pictures, you can see what it’s looking at!

5. Projector Tab 🌐

See high-dimensional data in 3D! It’s like putting on magic glasses to see invisible patterns.

graph TD
    A["TensorBoard"] --> B["Scalars 📈"]
    A --> C["Graphs 🕸️"]
    A --> D["Histograms 📊"]
    A --> E["Images 🖼️"]
    A --> F["Projector 🌐"]

Comparing Experiments

The COOLEST feature: Compare different training runs side by side!

Run experiment 1:

log_dir = "logs/experiment_1"

Run experiment 2:

log_dir = "logs/experiment_2"

Open TensorBoard once, see BOTH! Who learned faster? 🏁

🎯 Tuning Strategies

Why Tune?

Imagine you’re making lemonade 🍋. How much sugar? How much water? Too much sugar = too sweet. Too little = sour face!

Hyperparameters are like the recipe amounts for your AI:

• Learning rate (how fast to learn)
• Number of layers (how deep the brain)
• Neurons per layer (how wide each layer)

Finding the BEST combination = tuning!

Strategy 1: Manual Search

You try different values yourself:

# Try learning rate 0.01
model.compile(optimizer=tf.keras.optimizers.Adam(0.01))

# Didn't work? Try 0.001
model.compile(optimizer=tf.keras.optimizers.Adam(0.001))

Problem: Slow and boring! 😴

Strategy 2: Grid Search

Try EVERY combination in a grid:

Problem: If you have many options, this takes FOREVER!

Strategy 3: Random Search

Pick random combinations! Sometimes finds great results faster than grid search.

Strategy 4: Bayesian Optimization

The SMART way! 🧠 It learns which areas are promising and searches there more.

Think of it like:

• You lost your toy in the house
• You found a shoe in the bedroom
• Smart search: Look more in the bedroom!

graph TD
    A["Pick Strategy"] --> B{How many options?}
    B -->|Few| C["Grid Search ✅"]
    B -->|Many| D{Time available?}
    D -->|Lots| E["Bayesian 🧠"]
    D -->|Little| F["Random 🎲"]

🛠️ Keras Tuner

Your Automatic Recipe Tester!

Keras Tuner is like having a robot chef that tries hundreds of recipes and tells you the best one! 🤖👨‍🍳

Installing Keras Tuner

pip install keras-tuner

Building a Tunable Model

Instead of fixed values, you use choices:

import keras_tuner as kt

def build_model(hp):
    model = tf.keras.Sequential()

    # Let tuner pick neurons
    hp_units = hp.Int('units', min_value=32, max_value=512, step=32)
    model.add(tf.keras.layers.Dense(hp_units, activation='relu'))

    # Let tuner pick learning rate
    hp_lr = hp.Choice('learning_rate', [0.01, 0.001, 0.0001])
    model.compile(optimizer=tf.keras.optimizers.Adam(hp_lr))

    return model

Choosing a Tuner

# Random Search Tuner
tuner = kt.RandomSearch(
    build_model,
    objective='val_accuracy',
    max_trials=10,
    directory='my_tuning',
    project_name='my_project'
)

# OR Bayesian Tuner (smarter!)
tuner = kt.BayesianOptimization(
    build_model,
    objective='val_accuracy',
    max_trials=10
)

Running the Search

# Search for best hyperparameters
tuner.search(
    x_train, y_train,
    epochs=5,
    validation_data=(x_val, y_val)
)

# Get the best model
best_model = tuner.get_best_models(num_models=1)[0]

# See the best hyperparameters
best_hp = tuner.get_best_hyperparameters()[0]
print(f"Best units: {best_hp.get('units')}")
print(f"Best LR: {best_hp.get('learning_rate')}")

Types of Hyperparameters You Can Tune

graph TD
    A["Define Tunable Model"] --> B["Choose Tuner Type"]
    B --> C["Run Search"]
    C --> D["Get Best Model 🏆"]
    D --> E["Train Final Model"]

🎉 Putting It All Together

The Complete Workflow

1. Set up TensorBoard → Watch training live
2. Define tunable model → Use hp.Int(), hp.Choice()
3. Run Keras Tuner → Find best hyperparameters
4. Train final model → Use TensorBoard to monitor
5. Compare experiments → See what worked best!

Real Example

import tensorflow as tf
import keras_tuner as kt

# 1. Define tunable model
def build_model(hp):
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(
            hp.Int('units', 64, 256, 64),
            activation='relu'),
        tf.keras.layers.Dense(10, activation='softmax')
    ])
    model.compile(
        optimizer=tf.keras.optimizers.Adam(
            hp.Choice('lr', [0.01, 0.001])),
        loss='categorical_crossentropy',
        metrics=['accuracy'])
    return model

# 2. Create tuner
tuner = kt.BayesianOptimization(
    build_model,
    objective='val_accuracy',
    max_trials=5)

# 3. Search with TensorBoard
tuner.search(
    x_train, y_train,
    epochs=3,
    validation_data=(x_val, y_val),
    callbacks=[tf.keras.callbacks.TensorBoard("logs")])

# 4. Get winner!
best_model = tuner.get_best_models()[0]

🌟 Key Takeaways

🚀 You Did It!

Now you can:

• ✅ Set up TensorBoard to watch your AI learn
• ✅ Log custom metrics and images
• ✅ Use all TensorBoard features
• ✅ Choose the right tuning strategy
• ✅ Use Keras Tuner to find the best model automatically!

You’re no longer baking in the dark. You have X-ray vision into your AI’s brain, and a robot assistant to find the perfect recipe! 🎂🤖

Go build something amazing! 🌟