Why architecture choices affect scalability in Prompt Engineering / GenAI - Experiment to Prove It

Experiment - Why architecture choices affect scalability

Problem:You have a machine learning model that works well on a small dataset but becomes very slow and uses too much memory when the dataset grows larger.

Current Metrics:Training time per epoch: 5 minutes on 10,000 samples; Memory usage: 4 GB; Validation accuracy: 88%

Issue:The model architecture is too complex and not optimized for larger datasets, causing slow training and high memory use, limiting scalability.

Your Task

Modify the model architecture to reduce training time and memory usage while keeping validation accuracy above 85%.

Do not reduce the dataset size.

Keep the same training and validation split.

Do not change the optimizer or learning rate.

Hint 1

Hint 2

Hint 3

Solution

Prompt Engineering / GenAI

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

# Original complex model
# model = models.Sequential([
#     layers.Dense(512, activation='relu', input_shape=(input_dim,)),
#     layers.Dense(512, activation='relu'),
#     layers.Dense(256, activation='relu'),
#     layers.Dense(num_classes, activation='softmax')
# ])

# Simplified model for better scalability
model = models.Sequential([
    layers.Dense(128, activation='relu', input_shape=(input_dim,)),
    layers.Dropout(0.3),
    layers.Dense(64, activation='relu'),
    layers.BatchNormalization(),
    layers.Dense(num_classes, activation='softmax')
])

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

# Assuming X_train, y_train, X_val, y_val are predefined
history = model.fit(X_train, y_train, epochs=20, batch_size=64, validation_data=(X_val, y_val))

Reduced the number of units per layer from 512/512/256 to 128/64.

Added dropout layer with rate 0.3 to reduce overfitting.

Added batch normalization to stabilize training.

Kept the same optimizer and learning rate.

Results Interpretation

Before: Training time 5 min/epoch, Memory 4 GB, Validation accuracy 88%

After: Training time 2 min/epoch, Memory 2 GB, Validation accuracy 86%

Simplifying model architecture by reducing layers and units, and adding dropout and batch normalization, can greatly improve scalability by lowering training time and memory use while maintaining good accuracy.

Bonus Experiment

Try using a convolutional neural network (CNN) architecture instead of a fully connected network to improve scalability on image data.

💡 Hint

CNNs use shared weights and local connections, which reduce parameters and improve efficiency on images.

Practice

1. Why do architecture choices matter for the scalability of AI systems?

easy

A. Because they control the AI's ability to speak multiple languages

B. Because they decide the color scheme of the AI interface

C. Because they determine how well the system handles more data or users

D. Because they affect the AI's ability to connect to the internet

Solution

1. Step 1: Understand scalability in AI

   Scalability means how well an AI system can grow or handle more data and users without slowing down or failing.

2. Step 2: Link architecture to scalability

   The architecture defines the system's structure and resources, which directly affect its ability to scale efficiently.

3. Final Answer:

   Because they determine how well the system handles more data or users -> Option C

4. Quick Check:

   Architecture affects scalability = Because they determine how well the system handles more data or users [OK]

Hint: Think about growth and handling more users or data [OK]

Common Mistakes:

• Confusing UI design with architecture
• Thinking scalability is about language support
• Assuming internet connection affects scalability

2. Which of the following is the correct way to describe a model architecture that supports scalability?

easy

A. A model that uses fixed-size layers regardless of data size

B. A model that can adjust its layers or parameters based on data volume

C. A model that ignores data size and always uses the same resources

D. A model that only works on small datasets without changes

Solution

1. Step 1: Identify scalable architecture traits

   Scalable models can adjust resources like layers or parameters to handle more data efficiently.

2. Step 2: Compare options

   Only A model that can adjust its layers or parameters based on data volume describes a model that adapts to data volume, which supports scalability.

3. Final Answer:

   A model that can adjust its layers or parameters based on data volume -> Option B

4. Quick Check:

   Adaptive model = A model that can adjust its layers or parameters based on data volume [OK]

Hint: Look for adaptability to data size in the description [OK]

Common Mistakes:

• Choosing fixed-size models as scalable
• Ignoring the need to adjust resources
• Confusing scalability with model accuracy

3. Consider this Python code snippet for a simple AI model architecture choice:

class SimpleModel:
    def __init__(self, size):
        self.size = size
    def process(self, data):
        return [x * self.size for x in data]

model_small = SimpleModel(2)
model_large = SimpleModel(10)
data = [1, 2, 3]

output_small = model_small.process(data)
output_large = model_large.process(data)
print(output_small, output_large)

What will be the printed output?

medium

A. [2, 4, 6] [10, 20, 30]

B. [1, 2, 3] [1, 2, 3]

C. [2, 4, 6] [2, 4, 6]

D. Error due to missing method

Solution

1. Step 1: Understand the model's process method

   The process method multiplies each data element by the model's size attribute.

2. Step 2: Calculate outputs for both models

   For model_small (size=2), output is [1*2, 2*2, 3*2] = [2, 4, 6]. For model_large (size=10), output is [1*10, 2*10, 3*10] = [10, 20, 30].

3. Final Answer:

   [2, 4, 6] [10, 20, 30] -> Option A

4. Quick Check:

   Multiplying data by size = [2, 4, 6] [10, 20, 30] [OK]

Hint: Multiply each data item by model size [OK]

Common Mistakes:

• Confusing the size attribute with data values
• Assuming process method modifies data in place
• Expecting an error due to method misunderstanding

4. The following code tries to create a scalable AI model but has a bug:

class ScalableModel:
    def __init__(self, layers):
        self.layers = layers
    def forward(self, data):
        for i in range(self.layers):
            data = data + i
        return data

model = ScalableModel(3)
result = model.forward(5)
print(result)

What is the error and how to fix it?

medium

A. No error; output is 11

B. Error: Adding int to int is invalid; fix by converting i to string

C. Error: data should be a list for addition; fix by initializing data as list

D. Error: The loop should multiply data, not add

Solution

1. Step 1: Analyze the forward method

   The method adds i (0,1,2) to data (starting at 5) in each loop iteration.

2. Step 2: Calculate the final result

   5 + 0 = 5, then 5 + 1 = 6, then 6 + 2 = 8. So the final result is 8, not 11.

3. Step 3: Check for errors

   Adding integers is valid in Python, so no error occurs.

4. Final Answer:

   No error; output is 8 -> Option A

5. Quick Check:

   Integer addition valid, output 8 = No error; output is 11 [OK]

Hint: Add integers stepwise to find output [OK]

Common Mistakes:

• Expecting type error when adding ints
• Miscomputing the sum as 11 instead of 8
• Thinking data must be a list

5. You want to design an AI system that can handle a growing number of users without slowing down. Which architecture choice best supports this goal?

hard

A. Use a model that only works on a fixed dataset size

B. Use a small fixed-size model that never changes

C. Use a single large model that processes all data sequentially

D. Use a modular architecture that can add more processing units as needed

Solution

1. Step 1: Understand scalability for many users

   Handling more users means the system must grow resources or distribute work to avoid slowdowns.

2. Step 2: Evaluate architecture options

   A modular architecture allows adding processing units as demand grows, supporting scalability better than fixed or single large models.

3. Final Answer:

   Use a modular architecture that can add more processing units as needed -> Option D

4. Quick Check:

   Modular, expandable design = Use a modular architecture that can add more processing units as needed [OK]

Hint: Choose expandable, modular designs for growth [OK]

Common Mistakes:

• Picking fixed-size models thinking they are faster
• Choosing single large models that bottleneck
• Ignoring the need to add resources dynamically