Keras Cheat Sheet
High-level Keras API reference covering Sequential and Functional model building, compiling, training with callbacks, and common layer types.
2 PagesBeginnerApr 8, 2026
Sequential API
Stack layers linearly and compile.
python
from tensorflow import kerasfrom tensorflow.keras import layersmodel = keras.Sequential([ layers.Dense(128, activation="relu", input_shape=(784,)), layers.Dropout(0.3), layers.Dense(10, activation="softmax"),])model.compile( optimizer="adam", loss="sparse_categorical_crossentropy", metrics=["accuracy"],)
Functional API
Build models with non-linear topology.
python
inputs = keras.Input(shape=(784,))x = layers.Dense(128, activation="relu")(inputs)x = layers.Dense(64, activation="relu")(x)outputs = layers.Dense(10, activation="softmax")(x)model = keras.Model(inputs=inputs, outputs=outputs)
Train, Evaluate & Save
Fit the model and persist it to disk.
python
history = model.fit( X_train, y_train, validation_split=0.2, epochs=20, batch_size=32, callbacks=[keras.callbacks.EarlyStopping(patience=3, restore_best_weights=True)],)loss, acc = model.evaluate(X_test, y_test)model.save("my_model.keras")model2 = keras.models.load_model("my_model.keras")
Common Layers
Building blocks used across most models.
- Dense- fully connected layer
- Conv2D- 2D convolution for image inputs
- MaxPooling2D- downsamples feature maps
- LSTM / GRU- recurrent layers for sequence data
- Dropout- randomly zeroes inputs for regularization
- BatchNormalization- normalizes layer inputs for stable training
- Embedding- maps integer tokens to dense vectors
- Flatten- reshapes multi-dimensional input to 1D
Custom Training Loop with GradientTape
Bypass model.fit() for full control over the training step.
python
optimizer = keras.optimizers.Adam(learning_rate=1e-3)loss_fn = keras.losses.SparseCategoricalCrossentropy()train_acc_metric = keras.metrics.SparseCategoricalAccuracy()@tf.functiondef train_step(x, y): with tf.GradientTape() as tape: logits = model(x, training=True) loss_value = loss_fn(y, logits) grads = tape.gradient(loss_value, model.trainable_weights) optimizer.apply_gradients(zip(grads, model.trainable_weights)) train_acc_metric.update_state(y, logits) return loss_valuefor epoch in range(epochs): for x_batch, y_batch in train_dataset: loss_value = train_step(x_batch, y_batch) print(f"epoch {epoch}: acc={train_acc_metric.result():.4f}") train_acc_metric.reset_state()
Subclassed Models & Custom Layers
Build models imperatively and define reusable custom layers.
python
class ResidualBlock(layers.Layer): def __init__(self, units, **kwargs): super().__init__(**kwargs) self.dense1 = layers.Dense(units, activation="relu") self.dense2 = layers.Dense(units) self.add = layers.Add() def call(self, inputs, training=False): x = self.dense1(inputs) x = self.dense2(x) return tf.nn.relu(self.add([inputs, x]))class MyModel(keras.Model): def __init__(self): super().__init__() self.block1 = ResidualBlock(128) self.out = layers.Dense(10, activation="softmax") def call(self, inputs, training=False): x = self.block1(inputs, training=training) return self.out(x)
Custom Loss & Metric Classes
Extend keras.losses.Loss and keras.metrics.Metric for domain-specific objectives.
python
class FocalLoss(keras.losses.Loss): def __init__(self, gamma=2.0, alpha=0.25, **kwargs): super().__init__(**kwargs) self.gamma, self.alpha = gamma, alpha def call(self, y_true, y_pred): ce = keras.losses.sparse_categorical_crossentropy(y_true, y_pred) p_t = tf.exp(-ce) return self.alpha * (1 - p_t) ** self.gamma * ceclass F1Score(keras.metrics.Metric): def __init__(self, name="f1", **kwargs): super().__init__(name=name, **kwargs) self.precision = keras.metrics.Precision() self.recall = keras.metrics.Recall() def update_state(self, y_true, y_pred, sample_weight=None): self.precision.update_state(y_true, y_pred, sample_weight) self.recall.update_state(y_true, y_pred, sample_weight) def result(self): p, r = self.precision.result(), self.recall.result() return 2 * p * r / (p + r + keras.backend.epsilon())
Mixed Precision & tf.data Pipelines
Enable global mixed precision and build a performant input pipeline.
python
keras.mixed_precision.set_global_policy("mixed_float16")# Output layer must still produce float32 for numerical stabilityoutputs = layers.Dense(10, activation="softmax", dtype="float32")(x)train_ds = ( tf.data.Dataset.from_tensor_slices((X_train, y_train)) .shuffle(10000) .batch(64) .cache() .prefetch(tf.data.AUTOTUNE))model.fit(train_ds, epochs=10)
Advanced Keras Concepts
Deeper mechanisms beyond Sequential/Functional basics.
- model.get_layer(name).output- build feature-extractor sub-models for transfer learning
- layers.TFSMLayer- load a legacy SavedModel format into Keras 3 as an inference-only layer
- @tf.function(jit_compile=True)- enables XLA compilation of the train step for extra speed
- model.summary(expand_nested=True)- inspect nested submodel architectures layer by layer
- keras.utils.register_keras_serializable- decorator required so custom layers/losses survive save/load round-trips
- sample_weight vs class_weight- per-example vs per-class loss weighting for imbalanced datasets
- model.fit(..., steps_per_epoch=...)- required when passing an infinite/repeating tf.data.Dataset
Pro Tip
Combine EarlyStopping with ModelCheckpoint so you persist the best-performing weights seen during training, not just whatever the final epoch happens to produce.
Was this cheat sheet helpful?
Explore Topics
#Keras#KerasCheatSheet#DataScience#Beginner#SequentialAPI#FunctionalAPI#TrainEvaluateSave#CommonLayers#MachineLearning#APIs#CheatSheet#SkillVeris
