Practice Questions — Deep Learning with TensorFlow and Keras

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(64, activation='relu', input_shape=(100,)),
    Dense(10, activation='softmax')
])

print(model.output_shape)

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

model = Sequential([
    Dense(4, input_shape=(3,)),
    Dense(2)
])
model.summary()

model = Sequential([
    Dense(64, activation='relu', input_shape=(20,)),
    Dense(1, activation='???')
])

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

import numpy as np
X = np.random.rand(1, 784)
predictions = model.predict(X)
print(predictions.shape)
print(f"Sum of probabilities: {predictions.sum():.2f}")

# Labels are: [0, 3, 7, 2, 9, 1, 4, ...] (integers, not one-hot)
model.compile(optimizer='adam', loss='???', metrics=['accuracy'])

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout

model = Sequential([
    Dense(256, activation='relu', input_shape=(784,)),
    Dropout(0.3),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

for layer in model.layers:
    print(f"{layer.name}: {layer.output_shape}")

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

history = model.fit(X_train, y_train, epochs=5, validation_split=0.2)
print(list(history.history.keys()))

from tensorflow.keras.callbacks import EarlyStopping

early_stop = EarlyStopping(
    monitor='val_loss',
    patience=3,
    restore_best_weights=True
)

# Suppose val_loss over epochs is:
# Epoch 1: 0.50, Epoch 2: 0.45, Epoch 3: 0.40,
# Epoch 4: 0.42, Epoch 5: 0.43, Epoch 6: 0.44
# At which epoch does training stop?

from tensorflow.keras.layers import Dense
layer = Dense(64, input_shape=(128,))
layer.build(input_shape=(None, 128))
print(f"Weights shape: {layer.kernel.shape}")
print(f"Bias shape: {layer.bias.shape}")
print(f"Total params: {layer.count_params()}")

from tensorflow.keras.layers import Dense, Dropout
import numpy as np

# Dropout behavior check
layer = Dropout(0.5)

# Create input tensor
x = tf.constant([[1.0, 2.0, 3.0, 4.0]])

# During training
out_train = layer(x, training=True)
print(f"Training output has zeros: {(out_train.numpy() == 0).any()}")

# During inference
out_infer = layer(x, training=False)
print(f"Inference output: {out_infer.numpy()}")

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, BatchNormalization

model = Sequential([
    Dense(64, input_shape=(100,)),
    BatchNormalization(),
    Dense(10, activation='softmax')
])

total_params = model.count_params()
trainable = sum([layer.count_params() for layer in model.layers
                 if layer.trainable])
non_trainable = 0
for layer in model.layers:
    if isinstance(layer, BatchNormalization):
        non_trainable = sum([
            tf.size(w).numpy() for w in layer.non_trainable_weights
        ])

print(f"BatchNorm has {non_trainable} non-trainable params")

from tensorflow.keras.callbacks import ReduceLROnPlateau

reduce_lr = ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.5,
    patience=2,
    min_lr=1e-6
)

# Suppose initial learning rate = 0.001
# val_loss: E1=0.5, E2=0.4, E3=0.41, E4=0.42, E5=0.38, E6=0.39, E7=0.40
# What is the learning rate at each epoch?

model.save('my_model.keras')
loaded = keras.models.load_model('my_model.keras')
print(type(loaded))

import numpy as np
predictions = np.array([[0.05, 0.02, 0.85, 0.03, 0.05]])
predicted_class = predictions.argmax(axis=1)
print(predicted_class)

import numpy as np
X = np.array([0, 51, 102, 153, 204, 255])
X_normalized = X.astype('float32') / 255.0
print(X_normalized)

model.fit(X_train, y_train, epochs=50, batch_size=32)

from tensorflow.keras import Input, Model
from tensorflow.keras.layers import Dense, Concatenate

input_a = Input(shape=(10,))
input_b = Input(shape=(20,))

x = Concatenate()([input_a, input_b])
x = Dense(32, activation='relu')(x)
output = Dense(5, activation='softmax')(x)

model = Model(inputs=[input_a, input_b], outputs=output)
print(model.output_shape)

callbacks = [
    EarlyStopping(monitor='val_loss', patience=5, restore_best_weights=True),
    ModelCheckpoint('best.keras', monitor='val_accuracy', save_best_only=True, mode='max'),
    ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=3)
]

model.fit(X_train, y_train, epochs=100, validation_split=0.2, callbacks=callbacks)

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense, Dropout

model = Sequential([
    Dense(128, activation='relu', input_shape=(50,)),
    Dropout(0.5),
    Dense(64, activation='relu'),
    Dense(1, activation='sigmoid')
])

print(model.count_params())

model.fit(X_train, y_train, epochs=5)
model.fit(X_train, y_train, epochs=5)
print("Done")

model = Sequential([
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')
model.fit(X_train, y_train, epochs=5)

from tensorflow.keras import Input, Model
from tensorflow.keras.layers import Dense, Concatenate

input_a = Input(shape=(5,))
input_b = Input(shape=(3,))

x1 = Dense(4, activation='relu')(input_a)
x2 = Dense(4, activation='relu')(input_b)

merged = Concatenate()([x1, x2])
output = Dense(1, activation='sigmoid')(merged)

model = Model(inputs=[input_a, input_b], outputs=output)
print(model.count_params())

from tensorflow.keras import Sequential
from tensorflow.keras.layers import Dense

# Model expects 784 inputs
model = Sequential([
    Dense(128, activation='relu', input_shape=(784,)),
    Dense(10, activation='softmax')
])
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

# But data has shape (1000, 28, 28) -- not flattened
import numpy as np
X = np.random.rand(1000, 28, 28)
y = np.random.randint(0, 10, 1000)

model.fit(X, y, epochs=1)