# Keras 3 — works on any backend
import keras
from keras import layers

# Same code runs on TF, PyTorch, or JAX
model = keras.Sequential([
    layers.Dense(128, activation="relu"),
    layers.Dense(10, activation="softmax"),
])

# keras.ops — the universal operation layer
import keras

# These work identically on TF, PyTorch, or JAX:
x = keras.ops.matmul(a, b)
y = keras.ops.nn.softmax(logits)
z = keras.ops.image.resize(img, size=(224, 224))

# Install Keras
pip install keras

# Install your preferred backend
pip install tensorflow    # TensorFlow backend
pip install jax jaxlib    # JAX backend
pip install torch         # PyTorch backend

import os
os.environ["KERAS_BACKEND"] = "jax"  # Must be set BEFORE import keras
import keras

# Or check/set programmatically (Keras 3.5+):
keras.config.set_backend("torch")
print(keras.backend.backend())  # → "torch"

import os
os.environ["KERAS_BACKEND"] = "jax"
import keras  # Must come AFTER setting the env var

{{
    "backend": "jax",
    "floatx": "float32",
    "epsilon": 1e-07,
    "image_data_format": "channels_last"
}}

import keras
keras.config.set_backend("torch")  # Change backend after import

os.environ["KERAS_BACKEND"] = "tensorflow"
import keras

model = keras.Sequential([...])
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
model.fit(x_train, y_train)

# Export for TF Serving
model.export("serving_model", format="tf_saved_model")

os.environ["KERAS_BACKEND"] = "torch"
import keras
from keras import layers

model = keras.Sequential([
    layers.Dense(128, activation="relu"),
    layers.Dense(10, activation="softmax"),
])

# Keras model IS a torch.nn.Module
print(isinstance(model, torch.nn.Module))  # True

os.environ["KERAS_BACKEND"] = "jax"
import keras

model = keras.Sequential([...])
model.compile(optimizer="adam", loss="mse")

# JAX stateless API for functional purity
variables = model.variables
outputs = model.stateless_call(variables, inputs)

import keras
from keras import layers

# This model definition is 100% backend-agnostic
def build_model():
    inputs = keras.Input(shape=(784,))
    x = layers.Dense(256, activation="relu")(inputs)
    x = layers.Dropout(0.3)(x)
    x = layers.Dense(128, activation="relu")(x)
    x = layers.Dropout(0.3)(x)
    outputs = layers.Dense(10, activation="softmax")(x)
    return keras.Model(inputs, outputs)

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

# Train on any backend — same result
model.fit(x_train, y_train, epochs=10, validation_split=0.2)

# Save — cross-backend compatible!
model.save("my_model.keras")
# Load this on ANY backend — TF, PyTorch, JAX

import keras
from keras import layers

# Method 1: Pass a list of layers
model = keras.Sequential([
    keras.Input(shape=(784,)),
    layers.Dense(128, activation="relu"),
    layers.Dense(64, activation="relu"),
    layers.Dense(10, activation="softmax"),
])

# Method 2: Incremental add()
model = keras.Sequential()
model.add(keras.Input(shape=(784,)))
model.add(layers.Dense(128, activation="relu"))
model.add(layers.Dense(10, activation="softmax"))

model = keras.Sequential([
    keras.Input(shape=(28, 28, 1)),  # 28x28 grayscale images
    layers.Flatten(),                       # → (784,)
    layers.Dense(128, activation="relu"),   # → (128,)
    layers.Dropout(0.2),                   # Regularization
    layers.Dense(10, activation="softmax"), # → (10,) probabilities
])

model.summary()
# Output:
# ┏━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┓
# ┃ Layer (type)           ┃ Output Shape     ┃    Param # ┃
# ┡━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━┩
# │ dense (Dense)          │ (None, 128)      │    100,480 │
# │ dropout (Dropout)      │ (None, 128)      │          0 │
# │ dense_1 (Dense)        │ (None, 10)       │      1,290 │
# └───────────────────────┴──────────────────┴────────────┘

import keras
from keras import layers

# 1. Load data
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# 2. Normalize pixel values to [0, 1]
x_train = x_train.astype("float32") / 255.0
x_test = x_test.astype("float32") / 255.0

# 3. Build model
model = keras.Sequential([
    keras.Input(shape=(28, 28)),
    layers.Flatten(),
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.2),
    layers.Dense(10, activation="softmax"),
])

# 4. Compile
model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# 5. Train
model.fit(x_train, y_train, epochs=5, validation_split=0.1)

# 6. Evaluate
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {{test_acc:.4f}}")  # ~97.5%

import keras
from keras import layers

# Step 1: Define input
inputs = keras.Input(shape=(784,))

# Step 2: Chain layers
x = layers.Dense(256, activation="relu")(inputs)
x = layers.Dropout(0.3)(x)
x = layers.Dense(128, activation="relu")(x)
outputs = layers.Dense(10, activation="softmax")(x)

# Step 3: Create model
model = keras.Model(inputs=inputs, outputs=outputs, name="my_classifier")
model.summary()

# Multi-input, multi-output ticket classification
title_input = keras.Input(shape=(100,), name="title")
body_input = keras.Input(shape=(500,), name="body")
tags_input = keras.Input(shape=(12,), name="tags")

# Process each branch
title_features = layers.Dense(64, activation="relu")(title_input)
body_features = layers.Dense(128, activation="relu")(body_input)
tags_features = layers.Dense(32, activation="relu")(tags_input)

# Merge branches
x = layers.concatenate([title_features, body_features, tags_features])
x = layers.Dense(128, activation="relu")(x)

# Multiple outputs
priority = layers.Dense(3, activation="softmax", name="priority")(x)
department = layers.Dense(5, activation="softmax", name="department")(x)

model = keras.Model(
    inputs=[title_input, body_input, tags_input],
    outputs=[priority, department],
)

# A simple residual block
def residual_block(x, filters):
    shortcut = x  # Save the input

    x = layers.Dense(filters, activation="relu")(x)
    x = layers.Dense(filters)(x)

    # Add the skip connection
    x = layers.add([x, shortcut])
    x = layers.Activation("relu")(x)
    return x

# Use it in a model
inputs = keras.Input(shape=(128,))
x = layers.Dense(128, activation="relu")(inputs)
x = residual_block(x, 128)
x = residual_block(x, 128)
outputs = layers.Dense(10, activation="softmax")(x)
model = keras.Model(inputs, outputs)

# Shared embedding for a Siamese network
shared_embedding = layers.Dense(64, activation="relu", name="shared_embed")

input_a = keras.Input(shape=(128,))
input_b = keras.Input(shape=(128,))

# Same weights used for both inputs
encoded_a = shared_embedding(input_a)
encoded_b = shared_embedding(input_b)

# Compute distance
distance = layers.Lambda(
    lambda x: keras.ops.abs(x[0] - x[1])
)([encoded_a, encoded_b])
output = layers.Dense(1, activation="sigmoid")(distance)

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

# Use an existing model as a layer
encoder = keras.Model(encoder_inputs, encoded, name="encoder")
decoder = keras.Model(decoder_inputs, decoded, name="decoder")

# Nest them
inputs = keras.Input(shape=(784,))
z = encoder(inputs)       # Model called like a layer
outputs = decoder(z)
autoencoder = keras.Model(inputs, outputs)

# Print architecture
model.summary()

# Generate a diagram (requires pydot/graphviz)
keras.utils.plot_model(model, show_shapes=True, show_layer_names=True)

# Inspect intermediate outputs for debugging
intermediate_model = keras.Model(
    inputs=model.input,
    outputs=model.get_layer("dense_2").output,
)
intermediate_output = intermediate_model.predict(sample_data)

# Image branch
image_input = keras.Input(shape=(64, 64, 3), name="image")
x = layers.Conv2D(32, 3, activation="relu")(image_input)
x = layers.MaxPooling2D(2)(x)
x = layers.Conv2D(64, 3, activation="relu")(x)
x = layers.GlobalAveragePooling2D()(x)
image_features = layers.Dense(64, activation="relu")(x)

# Metadata branch
meta_input = keras.Input(shape=(10,), name="metadata")
meta_features = layers.Dense(32, activation="relu")(meta_input)

# Merge and predict
combined = layers.concatenate([image_features, meta_features])
x = layers.Dense(64, activation="relu")(combined)
x = layers.Dropout(0.3)(x)
output = layers.Dense(5, activation="softmax")(x)

model = keras.Model(
    inputs=[image_input, meta_input],
    outputs=output,
)

import keras
from keras import layers

class MyModel(keras.Model):
    def __init__(self):
        super().__init__()
        self.dense1 = layers.Dense(128, activation="relu")
        self.dropout = layers.Dropout(0.3)
        self.dense2 = layers.Dense(10, activation="softmax")

    def call(self, inputs, training=False):
        x = self.dense1(inputs)
        x = self.dropout(x, training=training)
        return self.dense2(x)

model = MyModel()
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
model.fit(x_train, y_train, epochs=5)

class MyDense(keras.layers.Layer):
    def __init__(self, units, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        # Lazy weight creation — called on first use
        self.w = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="glorot_uniform",
            trainable=True,
            name="kernel",
        )
        self.b = self.add_weight(
            shape=(self.units,),
            initializer="zeros",
            trainable=True,
            name="bias",
        )

    def call(self, inputs):
        return keras.ops.matmul(inputs, self.w) + self.b

    def get_config(self):
        config = super().get_config()
        config.update({{"units": self.units}})
        return config

class ConditionalLayer(keras.layers.Layer):
    def call(self, inputs, training=False):
        # Use keras.ops for backend-agnostic code!
        x = keras.ops.relu(inputs)
        if training:
            x = keras.ops.nn.dropout(x, rate=0.5)
        return x

# Custom layer
class ResidualBlock(keras.layers.Layer):
    def __init__(self, filters, **kwargs):
        super().__init__(**kwargs)
        self.dense1 = layers.Dense(filters, activation="relu")
        self.dense2 = layers.Dense(filters)
        self.add_layer = layers.Add()
        self.activation = layers.Activation("relu")

    def call(self, inputs):
        x = self.dense1(inputs)
        x = self.dense2(x)
        x = self.add_layer([x, inputs])
        return self.activation(x)

# Use custom layer in Functional API
inputs = keras.Input(shape=(64,))
x = layers.Dense(64, activation="relu")(inputs)
x = ResidualBlock(64)(x)  # Custom layer used like any built-in
x = ResidualBlock(64)(x)
outputs = layers.Dense(10, activation="softmax")(x)
model = keras.Model(inputs, outputs)

class CustomModel(keras.Model):
    def train_step(self, data):
        x, y = data

        # Forward pass with gradient tracking
        y_pred = self(x, training=True)
        loss = self.compute_loss(y=y, y_pred=y_pred)

        # Compute and apply gradients
        gradients = self.optimizer.compute_gradients(loss, self.trainable_variables)
        self.optimizer.apply(gradients)

        # Update metrics
        for metric in self.metrics:
            if metric.name == "loss":
                metric.update_state(loss)
            else:
                metric.update_state(y, y_pred)
        return {{m.name: m.result() for m in self.metrics}}

class TransformerBlock(keras.layers.Layer):
    def __init__(self, embed_dim, num_heads, ff_dim, rate=0.1, **kwargs):
        super().__init__(**kwargs)
        self.att = layers.MultiHeadAttention(
            num_heads=num_heads, key_dim=embed_dim
        )
        self.ffn = keras.Sequential([
            layers.Dense(ff_dim, activation="relu"),
            layers.Dense(embed_dim),
        ])
        self.norm1 = layers.LayerNormalization(epsilon=1e-6)
        self.norm2 = layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = layers.Dropout(rate)
        self.dropout2 = layers.Dropout(rate)

    def call(self, inputs, training=False):
        attn_output = self.att(inputs, inputs)
        attn_output = self.dropout1(attn_output, training=training)
        out1 = self.norm1(inputs + attn_output)
        ffn_output = self.ffn(out1)
        ffn_output = self.dropout2(ffn_output, training=training)
        return self.norm2(out1 + ffn_output)

# Embedding layer: integer tokens → dense vectors
embedding = layers.Embedding(
    input_dim=10000,   # Vocabulary size
    output_dim=128,     # Embedding dimension
    mask_zero=True,     # Treat 0 as padding
)
# Input shape: (batch, seq_len) of integers
# Output shape: (batch, seq_len, 128) of floats

# Standard Conv2D: 32 filters of 3×3
layers.Conv2D(32, kernel_size=3, activation="relu", padding="same")

# SeparableConv2D: same API, ~8x fewer params
layers.SeparableConv2D(32, kernel_size=3, activation="relu", padding="same")

# LSTM: Long Short-Term Memory
layers.LSTM(64, return_sequences=True)  # Output at every timestep
layers.LSTM(64)                             # Output at last timestep only

# GRU: Gated Recurrent Unit (simpler, often comparable)
layers.GRU(64)

# Bidirectional wrapper: processes sequence forward AND backward
layers.Bidirectional(layers.LSTM(64))

# Multi-head attention (Transformer key component)
layers.MultiHeadAttention(
    num_heads=8,          # Number of attention heads
    key_dim=64,           # Dimension of each head
    flash_attention=True,  # Enable Flash Attention (3.7+)
)

# Merge two branches
layers.Concatenate()([branch_a, branch_b])  # Concatenate along axis
layers.Add()([branch_a, branch_b])          # Element-wise addition
layers.Multiply()([branch_a, branch_b])     # Element-wise multiplication
layers.Average()([branch_a, branch_b])      # Element-wise average

# Numeric preprocessing
layers.Rescaling(1.0/255)             # Normalize pixel values
layers.Normalization()                  # Standardize features (.adapt() first)

# Text preprocessing
layers.TextVectorization(
    max_tokens=10000,
    output_mode="int",
    output_sequence_length=200,
)

# Category encoding
layers.CategoryEncoding(num_tokens=10)
layers.StringLookup(vocabulary=["cat", "dog", "bird"])

class SimpleAttention(keras.layers.Layer):
    def __init__(self, units, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def build(self, input_shape):
        self.W_q = self.add_weight(
            shape=(input_shape[-1], self.units), name="query_weight"
        )
        self.W_k = self.add_weight(
            shape=(input_shape[-1], self.units), name="key_weight"
        )
        self.W_v = self.add_weight(
            shape=(input_shape[-1], self.units), name="value_weight"
        )

    def call(self, inputs):
        q = keras.ops.matmul(inputs, self.W_q)
        k = keras.ops.matmul(inputs, self.W_k)
        v = keras.ops.matmul(inputs, self.W_v)

        # Scaled dot-product attention
        scale = keras.ops.sqrt(
            keras.ops.cast(self.units, dtype="float32")
        )
        scores = keras.ops.matmul(q, keras.ops.transpose(k)) / scale
        weights = keras.ops.nn.softmax(scores)
        return keras.ops.matmul(weights, v)

model.compile(
    optimizer="adam",                            # or keras.optimizers.Adam(1e-3)
    loss="sparse_categorical_crossentropy",      # or Loss instance
    metrics=["accuracy"],                        # list of metric names/instances
)

# For regression:
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=1e-3),
    loss="mse",
    metrics=["mae"],
)

# Cosine decay with warmup
lr_schedule = keras.optimizers.schedules.CosineDecay(
    initial_learning_rate=1e-3,
    decay_steps=10000,
    alpha=1e-6,       # Minimum learning rate
    warmup_target=1e-3,
    warmup_steps=1000,
)
optimizer = keras.optimizers.Adam(learning_rate=lr_schedule)

# Option A: softmax output + standard loss
model.compile(loss="sparse_categorical_crossentropy")

# Option B (preferred): no output activation + from_logits
model.compile(
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True)
)

model.compile(
    optimizer="adam",
    loss="sparse_categorical_crossentropy",
    metrics=[
        "accuracy",
        keras.metrics.SparseCategoricalAccuracy(name="acc"),
        keras.metrics.AUC(name="auc"),
        keras.metrics.Precision(name="precision"),
        keras.metrics.Recall(name="recall"),
        keras.metrics.F1Score(name="f1"),
    ],
)

history = model.fit(
    x_train, y_train,
    epochs=20,                 # Number of passes through the data
    batch_size=32,              # Samples per gradient update
    validation_split=0.2,       # Use 20% of training data for validation
    # OR: validation_data=(x_val, y_val),
    class_weight={{0: 1.0, 1: 5.0}},  # For imbalanced data
    callbacks=[...],              # List of callback instances
)

# history.history contains loss/metric values per epoch
print(history.history["loss"])         # [0.83, 0.54, 0.41, ...]
print(history.history["val_accuracy"]) # [0.72, 0.81, 0.85, ...]

callbacks = [
    # Stop when val_loss hasn't improved for 5 epochs
    keras.callbacks.EarlyStopping(
        monitor="val_loss",
        patience=5,
        restore_best_weights=True,  # Go back to best model
    ),

    # Save the best model
    keras.callbacks.ModelCheckpoint(
        "best_model.keras",
        monitor="val_loss",
        save_best_only=True,
    ),

    # Reduce LR when stuck
    keras.callbacks.ReduceLROnPlateau(
        monitor="val_loss",
        factor=0.5,     # Halve the LR
        patience=3,
        min_lr=1e-6,
    ),

    # Log to CSV
    keras.callbacks.CSVLogger("training_log.csv"),
]

model.fit(x_train, y_train, epochs=50, callbacks=callbacks)

# Evaluate on test data
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {{test_acc:.4f}}")

# Get predictions (probabilities)
predictions = model.predict(x_test)
# predictions.shape = (num_samples, num_classes)

# Convert probabilities to class labels
predicted_classes = keras.ops.argmax(predictions, axis=1)

import keras
from keras import layers

# Build model
model = keras.Sequential([
    keras.Input(shape=(784,)),
    layers.Dense(256, activation="relu"),
    layers.Dropout(0.3),
    layers.Dense(128, activation="relu"),
    layers.Dropout(0.2),
    layers.Dense(10, activation="softmax"),
])

# Compile
model.compile(
    optimizer=keras.optimizers.Adam(1e-3),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# Callbacks
callbacks = [
    keras.callbacks.EarlyStopping(
        monitor="val_loss", patience=5,
        restore_best_weights=True,
    ),
    keras.callbacks.ModelCheckpoint(
        "best.keras", save_best_only=True,
    ),
    keras.callbacks.ReduceLROnPlateau(
        factor=0.5, patience=3,
    ),
]

# Train
history = model.fit(
    x_train, y_train,
    epochs=50,
    batch_size=32,
    validation_split=0.2,
    callbacks=callbacks,
)

class CustomModel(keras.Model):
    def train_step(self, data):
        x, y = data

        # Forward pass + loss
        y_pred = self(x, training=True)
        loss = self.compute_loss(y=y, y_pred=y_pred)

        # Compute and apply gradients
        grads = self.optimizer.compute_gradients(
            loss, self.trainable_variables
        )
        self.optimizer.apply(grads)

        # Update and return metrics
        for metric in self.metrics:
            if metric.name == "loss":
                metric.update_state(loss)
            else:
                metric.update_state(y, y_pred)

        return {{m.name: m.result() for m in self.metrics}}

# Still use fit()!
model = CustomModel(...)
model.compile(optimizer="adam", loss="mse")
model.fit(x_train, y_train, epochs=10)

# Backend-agnostic manual training loop
optimizer = keras.optimizers.Adam(1e-3)
loss_fn = keras.losses.SparseCategoricalCrossentropy()

for epoch in range(10):
    for step, (x_batch, y_batch) in enumerate(train_dataset):
        # Forward pass with gradient tracking
        y_pred = model(x_batch, training=True)
        loss = loss_fn(y_batch, y_pred)

        # Compute gradients and update weights
        grads = optimizer.compute_gradients(
            loss, model.trainable_variables
        )
        optimizer.apply(grads)

    print(f"Epoch {{epoch}}, Loss: {{loss:.4f}}")

class GAN(keras.Model):
    def __init__(self, generator, discriminator, latent_dim):
        super().__init__()
        self.generator = generator
        self.discriminator = discriminator
        self.latent_dim = latent_dim

    def train_step(self, real_images):
        batch_size = keras.ops.shape(real_images)[0]
        noise = keras.random.normal(
            shape=(batch_size, self.latent_dim)
        )

        # Train discriminator
        fake_images = self.generator(noise)
        combined = keras.ops.concatenate([real_images, fake_images])
        labels = keras.ops.concatenate([
            keras.ops.ones((batch_size, 1)),
            keras.ops.zeros((batch_size, 1)),
        ])
        d_loss = self._train_discriminator(combined, labels)

        # Train generator
        noise = keras.random.normal(shape=(batch_size, self.latent_dim))
        misleading_labels = keras.ops.ones((batch_size, 1))
        g_loss = self._train_generator(noise, misleading_labels)

        return {{"d_loss": d_loss, "g_loss": g_loss}}

accumulation_steps = 4  # Effective batch = batch_size × 4

for step, (x, y) in enumerate(dataset):
    # Compute gradients
    y_pred = model(x, training=True)
    loss = loss_fn(y, y_pred) / accumulation_steps

    grads = optimizer.compute_gradients(
        loss, model.trainable_variables
    )

    # Accumulate
    if step % accumulation_steps == 0:
        accumulated_grads = grads
    else:
        accumulated_grads = [
            (a + g) for a, g in zip(accumulated_grads, grads)
        ]

    # Apply every N steps
    if (step + 1) % accumulation_steps == 0:
        optimizer.apply(accumulated_grads)

# Normalization: learns mean/variance from data
normalizer = layers.Normalization()
normalizer.adapt(training_data)  # Must see data first

# Rescaling: simple linear transform
rescaler = layers.Rescaling(1.0 / 255.0)

# TextVectorization: text → integer tokens
vectorizer = layers.TextVectorization(
    max_tokens=20000,
    output_sequence_length=200,
)
vectorizer.adapt(text_data)

# Put inside the model
model = keras.Sequential([
    rescaler,                                    # Preprocessing
    layers.Conv2D(32, 3, activation="relu"),  # Model layers
    layers.GlobalAveragePooling2D(),
    layers.Dense(10, activation="softmax"),
])

# Built-in Keras augmentation layers
data_augmentation = keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.1),        # ±10% of full rotation
    layers.RandomZoom(0.1),            # ±10% zoom
    layers.RandomContrast(0.1),        # ±10% contrast
])

# Applied only during training (training=True)
# At inference time, augmentation is a no-op

# All of these work with model.fit():
model.fit(numpy_x, numpy_y)              # NumPy arrays
model.fit(tf_dataset)                     # tf.data.Dataset
model.fit(torch_dataloader)               # PyTorch DataLoader
model.fit(keras_pydataset)                # keras.utils.PyDataset

# Folder structure:
# data/
#   cats/
#     cat001.jpg
#     cat002.jpg
#   dogs/
#     dog001.jpg
#     dog002.jpg

train_ds = keras.utils.image_dataset_from_directory(
    "data/",
    image_size=(224, 224),   # Resize all images
    batch_size=32,
    validation_split=0.2,
    subset="training",
    seed=42,
    label_mode="categorical", # or "int" for integer labels
)

# 1. class_weight in model.fit()
model.fit(x, y, class_weight={{0: 1.0, 1: 10.0}})

# 2. sample_weight array (per-sample importance)
weights = np.where(y_train == 1, 10.0, 1.0)
model.fit(x, y, sample_weight=weights)

# 3. Oversample minority class in the pipeline
# (duplicate minority samples or use SMOTE)

import keras
from keras import layers

# Data augmentation layers (only active during training)
augmentation = keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.1),
    layers.RandomZoom(0.1),
])

# Model with preprocessing built in
model = keras.Sequential([
    keras.Input(shape=(224, 224, 3)),
    layers.Rescaling(1.0 / 255.0),   # Normalize
    augmentation,                       # Augment
    layers.Conv2D(32, 3, activation="relu"),
    layers.MaxPooling2D(2),
    layers.Conv2D(64, 3, activation="relu"),
    layers.MaxPooling2D(2),
    layers.GlobalAveragePooling2D(),
    layers.Dense(128, activation="relu"),
    layers.Dense(5, activation="softmax"),
])

model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
model.fit(train_ds, validation_data=val_ds, epochs=20)

# Load pretrained model (without classification head)
base_model = keras.applications.EfficientNetV2S(
    weights="imagenet",
    include_top=False,      # Remove classification layers
    input_shape=(224, 224, 3),
)

# Freeze the pretrained weights
base_model.trainable = False

# Add a custom classification head
inputs = keras.Input(shape=(224, 224, 3))
x = base_model(inputs, training=False)  # Keep BN in inference mode
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dropout(0.2)(x)
outputs = layers.Dense(5, activation="softmax")(x)

model = keras.Model(inputs, outputs)
model.compile(
    optimizer="adam",
    loss="categorical_crossentropy",
    metrics=["accuracy"],
)

# Train only the head (~5-10 epochs)
model.fit(train_ds, epochs=10, validation_data=val_ds)

# Unfreeze the top layers of the base model
base_model.trainable = True

# Freeze everything except the top 20 layers
for layer in base_model.layers[:-20]:
    layer.trainable = False

# CRITICAL: Re-compile with a very low learning rate
model.compile(
    optimizer=keras.optimizers.Adam(1e-5),  # 100x lower!
    loss="categorical_crossentropy",
    metrics=["accuracy"],
)

# Continue training (~10-20 more epochs)
model.fit(train_ds, epochs=20, validation_data=val_ds)

import keras_hub

# Load a pretrained NLP model
classifier = keras_hub.models.BertClassifier.from_preset(
    "bert_base_en",
    num_classes=4,
)

# Available models include:
# BERT, GPT-2, Gemma (1/2/3/4), Llama 2/3,
# Mistral, T5, Whisper, Qwen, and many more

# Fine-tune with LoRA for efficiency
classifier.backbone.enable_lora(rank=4)
classifier.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
classifier.fit(train_ds, epochs=3)

import keras
from keras import layers

# Load pretrained EfficientNetV2S
base = keras.applications.EfficientNetV2S(
    weights="imagenet", include_top=False,
    input_shape=(224, 224, 3),
)
base.trainable = False

# Build model
inputs = keras.Input(shape=(224, 224, 3))
x = base(inputs, training=False)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(128, activation="relu")(x)
x = layers.Dropout(0.3)(x)
outputs = layers.Dense(5, activation="softmax")(x)
model = keras.Model(inputs, outputs)

# Phase 1: Feature extraction
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics=["accuracy"])
model.fit(train_ds, epochs=10, validation_data=val_ds)

# Phase 2: Fine-tuning
base.trainable = True
for layer in base.layers[:-20]:
    layer.trainable = False
model.compile(optimizer=keras.optimizers.Adam(1e-5), loss="categorical_crossentropy", metrics=["accuracy"])
model.fit(train_ds, epochs=20, validation_data=val_ds)

# Save the complete model
model.save("my_model.keras")

# Load it back
loaded_model = keras.models.load_model("my_model.keras")

# Save weights
model.save_weights("weights.weights.h5")

# Load weights into an identical architecture
new_model = build_model()  # Must match original architecture
new_model.load_weights("weights.weights.h5")

# Weight sharding for large models (Keras 3.10+)
model.save_weights("large_model.weights.h5", max_shard_size="2GB")

# Train on JAX (fast JIT compilation)
os.environ["KERAS_BACKEND"] = "jax"
model.fit(x_train, y_train, epochs=10)
model.save("trained_on_jax.keras")

# Later: load on TensorFlow for deployment
os.environ["KERAS_BACKEND"] = "tensorflow"
model = keras.models.load_model("trained_on_jax.keras")
model.export("tf_serving_model", format="tf_saved_model")

# TF SavedModel (for TF Serving)
model.export("model_dir", format="tf_saved_model")

# ONNX (cross-platform inference)
model.export("model.onnx", format="onnx")

# OpenVINO (Intel optimized inference)
model.export("model_ov", format="openvino")

# TFLite (mobile/edge)
model.export("model.tflite", format="litert")

@keras.saving.register_keras_serializable(package="my_package")
class MyCustomLayer(keras.layers.Layer):
    def __init__(self, units, **kwargs):
        super().__init__(**kwargs)
        self.units = units

    def get_config(self):
        config = super().get_config()
        config.update({{"units": self.units}})
        return config

# Now model.save() / load_model() works with custom objects

# Step 1: Train on JAX
os.environ["KERAS_BACKEND"] = "jax"
import keras
model = build_model()
model.compile(optimizer="adam", loss="sparse_categorical_crossentropy")
model.fit(x_train, y_train, epochs=10)
model.save("model.keras")

# Step 2: Load on TensorFlow
# (In a new script with KERAS_BACKEND="tensorflow")
model = keras.models.load_model("model.keras")

# Step 3: Export for production
model.export("production_model", format="tf_saved_model")
# Deploy with TF Serving, TFLite, or TF.js

import keras_cv

# Load a pretrained backbone
backbone = keras_cv.models.EfficientNetV2Backbone.from_preset(
    "efficientnetv2_s_imagenet"
)

# Load YOLOV8 with COCO pretrained weights
detector = keras_cv.models.YOLOV8Detector.from_preset(
    "yolo_v8_m_coco",  # xs, s, m, l, xl sizes
)

# Run inference
predictions = detector.predict(images)
# predictions["boxes"] → bounding box coordinates
# predictions["classes"] → class IDs
# predictions["confidence"] → confidence scores

# CutMix and MixUp
augmenter = keras_cv.layers.CutMix(alpha=1.0)
augmenter = keras_cv.layers.MixUp(alpha=0.2)

# RandAugment
augmenter = keras_cv.layers.RandAugment(
    value_range=(0, 255), augmentations_per_image=3
)

import keras_cv

# Load pretrained YOLOV8
model = keras_cv.models.YOLOV8Detector.from_preset(
    "yolo_v8_m_coco",
)

# Prepare image
image = keras.utils.load_img("photo.jpg", target_size=(640, 640))
image_array = keras.utils.img_to_array(image)
image_batch = keras.ops.expand_dims(image_array, axis=0)

# Run detection
predictions = model.predict(image_batch)
# Process bounding boxes, classes, and confidence scores

import keras_hub

# Load a pretrained classifier
classifier = keras_hub.models.BertClassifier.from_preset(
    "bert_base_en",
    num_classes=4,
)

# Load a text generator
gpt2 = keras_hub.models.GPT2CausalLM.from_preset("gpt2_base_en")

# Tokenizers are included with model presets
tokenizer = keras_hub.tokenizers.WordPieceTokenizer(
    vocabulary=vocab_data,
)

# Or use the tokenizer that comes with a preset
preprocessor = keras_hub.models.BertPreprocessor.from_preset(
    "bert_base_en",
    sequence_length=128,
)

import keras_hub

# Load BERT for classification
classifier = keras_hub.models.BertClassifier.from_preset(
    "bert_base_en",
    num_classes=2,  # Binary sentiment
)

# Compile and train
classifier.compile(
    optimizer=keras.optimizers.Adam(5e-5),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)
classifier.fit(train_ds, validation_data=val_ds, epochs=3)

# Load GPT-2 for text generation
gpt2 = keras_hub.models.GPT2CausalLM.from_preset("gpt2_base_en")

# Generate with various sampling strategies
output = gpt2.generate(
    "The future of AI is",
    max_length=100,
)
print(output)

# Control generation with temperature, top_k, top_p
gpt2.compile(sampler=keras_hub.samplers.TopKSampler(k=50, temperature=0.7))

# Enable LoRA on the model backbone
classifier.backbone.enable_lora(rank=4)

# Check trainable params — dramatically reduced!
print(classifier.summary())
# Total params: 110M, Trainable: ~300K (0.3%!)

# QLoRA: Quantize first, then LoRA
classifier.backbone.quantize("int8")     # Reduce model size
classifier.backbone.enable_lora(rank=4)  # Add adapters
# Even less memory, nearly same quality

import keras
import keras_hub

# Load pretrained classifier
classifier = keras_hub.models.BertClassifier.from_preset(
    "bert_base_en",
    num_classes=3,
)

# Enable LoRA for efficient fine-tuning
classifier.backbone.enable_lora(rank=4)

# Compile
classifier.compile(
    optimizer=keras.optimizers.AdamW(5e-5),
    loss="sparse_categorical_crossentropy",
    metrics=["accuracy"],
)

# Train
classifier.fit(
    train_ds,
    validation_data=val_ds,
    epochs=3,
)

# Save the fine-tuned model
classifier.save("my_classifier.keras")

import keras_tuner

def build_model(hp):
    model = keras.Sequential([
        keras.Input(shape=(784,)),
        layers.Dense(
            units=hp.Int("units", min_value=32, max_value=512, step=32),
            activation="relu",
        ),
        layers.Dropout(hp.Float("dropout", 0.0, 0.5, step=0.1)),
        layers.Dense(10, activation="softmax"),
    ])
    model.compile(
        optimizer=keras.optimizers.Adam(
            hp.Float("lr", 1e-4, 1e-2, sampling="log")
        ),
        loss="sparse_categorical_crossentropy",
        metrics=["accuracy"],
    )
    return model

# Search strategies
tuner = keras_tuner.BayesianOptimization(
    build_model, objective="val_accuracy", max_trials=20,
)
tuner.search(x_train, y_train, epochs=10, validation_split=0.2)
best_model = tuner.get_best_models()[0]

# Enable mixed precision globally
keras.mixed_precision.set_global_policy("mixed_float16")

# Build and train normally — Keras handles the casting
model = keras.Sequential([
    keras.Input(shape=(784,)),
    layers.Dense(256, activation="relu"),  # Computes in float16
    layers.Dense(10),                        # Raw logits (no activation)
])

# Use from_logits for numerical stability with mixed precision
model.compile(
    optimizer="adam",
    loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
)

# Data parallelism: same model on each GPU, split data
devices = keras.distribution.list_devices("gpu")
data_parallel = keras.distribution.DataParallel(devices=devices)

# Set distribution before building the model
keras.distribution.set_distribution(data_parallel)

model = build_model()
model.compile(optimizer="adam", loss="mse")
model.fit(x_train, y_train)  # Automatically distributed!

# Model parallelism: split model across GPUs
device_mesh = keras.distribution.DeviceMesh(
    shape=(2,), axis_names=["model"], devices=devices
)
layout_map = keras.distribution.LayoutMap(device_mesh)
layout_map["dense/kernel"] = keras.distribution.TensorLayout(["model", None])

# Int8 quantization (4x smaller, faster inference)
model.quantize("int8")

# Int4 quantization (8x smaller, Keras 3.11+)
model.quantize("int4")

# Selective quantization (exclude specific layers)
model.quantize("int8", type_filter=["Dense"])  # Only Dense layers

class Distiller(keras.Model):
    def __init__(self, student, teacher, temperature=3.0, alpha=0.1):
        super().__init__()
        self.student = student
        self.teacher = teacher
        self.temperature = temperature
        self.alpha = alpha

    def train_step(self, data):
        x, y = data
        # Teacher predictions (soft labels)
        teacher_pred = self.teacher(x, training=False)

        # Student predictions
        student_pred = self.student(x, training=True)

        # Distillation loss (soft) + student loss (hard)
        loss = (
            self.alpha * hard_loss(y, student_pred) +
            (1 - self.alpha) * soft_loss(teacher_pred, student_pred)
        )
        ...

# Gradient clipping to prevent NaN
optimizer = keras.optimizers.Adam(
    learning_rate=1e-3,
    clipnorm=1.0,  # Clip gradient norm
)