Understanding Keras

Technical Mastery: Building, Training, and Introspection

Keras is designed for **Progressive Disclosure of Complexity**. In this chapter, we master the technical specifics: from building models layer-by-layer to orchestrating complex multi-sensor systems through the Functional API.

We'll look at how weights are initialized, how to visualize model architecture, and how to "extract" features from existing models for new applications.

Incremental Building and Introspection

A **Sequential** model can be built incrementally using the `.add()` method. Until you call `.build()` or pass an input shape to the first layer, the model's weights aren't initialized because Keras doesn't know the input dimension yet. We use `.summary()` to follow how the output shape changes as we add layers.

PythonRuns entirely in your browser — nothing is sent to a server.

# Simulation: Incremental Building and Weight Shapes
class KerasSequential:
    def __init__(self, name="AV_Vision"):
        self.name = name
        self.layers = []
        self.built = False

    def add(self, layer_name, output_dim):
        self.layers.append({"name": layer_name, "out": output_dim})
        print(f"Added layer: {layer_name} (Output: {output_dim})")

    def build(self, input_shape):
        print(f"--- Building Model {self.name} with input {input_shape} ---")
        self.built = True
        current_shape = input_shape
        for l in self.layers:
            print(f"Layer '{l['name']}': Weights initialized for {current_shape} -> {l['out']}")
            current_shape = l['out']

    def summary(self):
        print("\nModel: {0} Summary".format(self.name))
        print("Layer (type)               Output Shape")
        print("========================================")
        for i, l in enumerate(self.layers):
            print("layer_{0} ({1})        (None, {2})".format(i, l['name'], l['out']))

model = KerasSequential("Braking_Predictor")
model.add("Dense_Hidden", 64)
model.add("Dense_Output", 1)
model.build(input_shape=32) # e.g., 32 sensor features
model.summary()

# Simulation: Incremental Building and Weight Shapes
class KerasSequential:
    def __init__(self, name="AV_Vision"):
        self.name = name
        self.layers = []
        self.built = False

    def add(self, layer_name, output_dim):
        self.layers.append({"name": layer_name, "out": output_dim})
        print(f"Added layer: {layer_name} (Output: {output_dim})")

    def build(self, input_shape):
        print(f"--- Building Model {self.name} with input {input_shape} ---")
        self.built = True
        current_shape = input_shape
        for l in self.layers:
            print(f"Layer '{l['name']}': Weights initialized for {current_shape} -> {l['out']}")
            current_shape = l['out']

    def summary(self):
        print("\nModel: {0} Summary".format(self.name))
        print("Layer (type)               Output Shape")
        print("========================================")
        for i, l in enumerate(self.layers):
            print("layer_{0} ({1})        (None, {2})".format(i, l['name'], l['out']))

model = KerasSequential("Braking_Predictor")
model.add("Dense_Hidden", 64)
model.add("Dense_Output", 1)
model.build(input_shape=32) # e.g., 32 sensor features
model.summary()

Multi-Modal Systems with the Functional API

Complex tasks like Autonomous Driving require **Multiple Inputs** (Camera + LiDAR) and **Multiple Outputs** (Steering + Speed). The Functional API uses **Symbolic Tensors** to build an acyclic graph of layers. We can train these multi-modal models by passing data via dictionaries to the `fit()` method.

PythonRuns entirely in your browser — nothing is sent to a server.

# Simulation: Multi-Input/Output AV System
class SensorFusionModel:
    def __init__(self, inputs, outputs):
        self.inputs = inputs # e.g., {'cam': tensor_A, 'lidar': tensor_B}
        self.outputs = outputs # e.g., {'steer': tensor_C, 'accel': tensor_D}

    def fit(self, data_dict, epochs=5):
        print(f"Starting Multi-Modal Training...")
        print(f"Inputs detected: {list(data_dict.keys())}")
        for epoch in range(1, epochs + 1):
            # Combined Loss calculation across multiple outputs
            print(f"Epoch {epoch}: [Steer_Loss: 0.12, Accel_Loss: 0.05] Total: 0.17")

# Defining the Graph (Symbolic Simulation)
cam_input = "Tensor(Shape=[224, 224, 3])"
lidar_input = "Tensor(Shape=[1024, 6])"

# Data passed via dictionary for clarity
train_data = {
    'camera_stream': [0.1, 0.2, 0.3], # Simulated normalized data
    'lidar_cloud': [0.8, 0.9, 0.7]
}

model = SensorFusionModel(inputs=[cam_input, lidar_input], outputs=['steer', 'speed'])
model.fit(train_data)

# Simulation: Multi-Input/Output AV System
class SensorFusionModel:
    def __init__(self, inputs, outputs):
        self.inputs = inputs # e.g., {'cam': tensor_A, 'lidar': tensor_B}
        self.outputs = outputs # e.g., {'steer': tensor_C, 'accel': tensor_D}

    def fit(self, data_dict, epochs=5):
        print(f"Starting Multi-Modal Training...")
        print(f"Inputs detected: {list(data_dict.keys())}")
        for epoch in range(1, epochs + 1):
            # Combined Loss calculation across multiple outputs
            print(f"Epoch {epoch}: [Steer_Loss: 0.12, Accel_Loss: 0.05] Total: 0.17")

# Defining the Graph (Symbolic Simulation)
cam_input = "Tensor(Shape=[224, 224, 3])"
lidar_input = "Tensor(Shape=[1024, 6])"

# Data passed via dictionary for clarity
train_data = {
    'camera_stream': [0.1, 0.2, 0.3], # Simulated normalized data
    'lidar_cloud': [0.8, 0.9, 0.7]
}

model = SensorFusionModel(inputs=[cam_input, lidar_input], outputs=['steer', 'speed'])
model.fit(train_data)

Feature Extraction and Reuse

A model isn't just a black box; it's a hierarchy of features. **Feature Extraction** involves accessing intermediate layers of a pre-trained model to reuse those patterns for a new task. For example, a model trained to detect lung nodes can have its intermediate "texture" features extracted to help detect other anomalies.

PythonRuns entirely in your browser — nothing is sent to a server.

# Simulation: Feature Extraction (Transfer Learning)
class ClinicalFoundationModel:
    def __init__(self):
        self.layers = ["Input", "Edges", "Textures", "Lung_Shapes", "Cancer_Output"]

    def extract_features(self, layer_name):
        idx = self.layers.index(layer_name)
        extracted = self.layers[:idx+1]
        return f"New Model: Using pretrained {extracted} as base."

# Reuse the Foundation Model for a new task: Rib Fracture Detection
foundation = ClinicalFoundationModel()
# We don't need 'Cancer_Output', but 'Textures' and 'Edges' are valuable!
base_model = foundation.extract_features("Textures")

print(f"Base for Fracture System: {base_model}")
print("Integration: Adding new 'Fracture_Dense_Head' on top of extracted features.")

# Simulation: Feature Extraction (Transfer Learning)
class ClinicalFoundationModel:
    def __init__(self):
        self.layers = ["Input", "Edges", "Textures", "Lung_Shapes", "Cancer_Output"]

    def extract_features(self, layer_name):
        idx = self.layers.index(layer_name)
        extracted = self.layers[:idx+1]
        return f"New Model: Using pretrained {extracted} as base."

# Reuse the Foundation Model for a new task: Rib Fracture Detection
foundation = ClinicalFoundationModel()
# We don't need 'Cancer_Output', but 'Textures' and 'Edges' are valuable!
base_model = foundation.extract_features("Textures")

print(f"Base for Fracture System: {base_model}")
print("Integration: Adding new 'Fracture_Dense_Head' on top of extracted features.")

Practice Questions

Question 1

Which Keras API is most suitable for a model with multiple inputs (e.g., Image + Tabular data)?

Sequential API
Functional API
Global API
Static API

Question 2

When would you prefer a Custom Training Loop (GradientTape) over model.fit()?

When the dataset is small
When you need specific control over the low-level gradients or complex safety constraints
When you want the code to run faster
When you don't know how to use fit()