🧪

from tensorflow import keras
from tensorflow.keras import layers

model = keras.Sequential([
    layers.Dense(64, activation='relu', input_shape=(784,)),
    layers.Dropout(0.2),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Or add layers
model = keras.Sequential()
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))

inputs = keras.Input(shape=(784,))
x = layers.Dense(64, activation='relu')(inputs)
x = layers.Dense(64, activation='relu')(x)
outputs = layers.Dense(10, activation='softmax')(x)

model = keras.Model(inputs=inputs, outputs=outputs)

# Multiple inputs/outputs
input_a = keras.Input(shape=(32,), name='input_a')
input_b = keras.Input(shape=(32,), name='input_b')
x = layers.concatenate([input_a, input_b])
output = layers.Dense(1)(x)
model = keras.Model(inputs=[input_a, input_b], outputs=output)

# Fully connected layer
layers.Dense(units=64, activation='relu')
layers.Dense(units=10, activation='softmax')

# With regularization
layers.Dense(64,
    kernel_regularizer=keras.regularizers.l2(0.01),
    bias_regularizer=keras.regularizers.l1(0.01),
    activity_regularizer=keras.regularizers.l1_l2(l1=0.01, l2=0.01)
)

# 2D Convolution
layers.Conv2D(filters=32, kernel_size=(3, 3), activation='relu', padding='same')

# 1D Convolution (for sequences)
layers.Conv1D(filters=32, kernel_size=3, activation='relu')

# Transposed (deconvolution)
layers.Conv2DTranspose(32, (3, 3), strides=(2, 2), padding='same')

# Separable convolution
layers.SeparableConv2D(32, (3, 3))

layers.MaxPooling2D(pool_size=(2, 2))
layers.AveragePooling2D(pool_size=(2, 2))
layers.GlobalMaxPooling2D()
layers.GlobalAveragePooling2D()

# 1D pooling
layers.MaxPooling1D(pool_size=2)
layers.GlobalMaxPooling1D()

# LSTM
layers.LSTM(64, return_sequences=True)  # For stacking
layers.LSTM(64, return_sequences=False) # For output

# GRU
layers.GRU(64, return_sequences=True)

# Bidirectional
layers.Bidirectional(layers.LSTM(64, return_sequences=True))

# SimpleRNN
layers.SimpleRNN(64)

# Dropout
layers.Dropout(0.5)
layers.SpatialDropout2D(0.5)  # For Conv2D

# Batch normalization
layers.BatchNormalization()

# Layer normalization
layers.LayerNormalization()

# Word embedding
layers.Embedding(
    input_dim=vocab_size,  # Vocabulary size
    output_dim=embedding_dim,  # Embedding dimension
    input_length=max_length  # Sequence length
)

# Multi-head attention
layers.MultiHeadAttention(
    num_heads=8,
    key_dim=64,
    dropout=0.1
)

# Additive attention
layers.Attention()([query, value])

layers.Flatten()
layers.Reshape((4, 4, 3))
layers.Permute((2, 1))
layers.RepeatVector(3)

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

# With custom optimizer
model.compile(
    optimizer=keras.optimizers.Adam(learning_rate=0.001),
    loss=keras.losses.SparseCategoricalCrossentropy(),
    metrics=[keras.metrics.SparseCategoricalAccuracy()]
)

keras.optimizers.SGD(learning_rate=0.01, momentum=0.9)
keras.optimizers.Adam(learning_rate=0.001)
keras.optimizers.RMSprop(learning_rate=0.001)
keras.optimizers.Adagrad(learning_rate=0.01)
keras.optimizers.AdamW(learning_rate=0.001, weight_decay=0.01)

# Classification
'binary_crossentropy'          # Binary classification
'categorical_crossentropy'     # Multi-class (one-hot)
'sparse_categorical_crossentropy'  # Multi-class (integer labels)

# Regression
'mse'                          # Mean squared error
'mae'                          # Mean absolute error
'huber'                        # Huber loss

# Custom
keras.losses.BinaryCrossentropy(from_logits=True)

history = model.fit(
    x_train, y_train,
    epochs=10,
    batch_size=32,
    validation_split=0.2,
    # or validation_data=(x_val, y_val),
    callbacks=[...],
    verbose=1
)

# Access history
history.history['loss']
history.history['accuracy']
history.history['val_loss']

# Early stopping
keras.callbacks.EarlyStopping(
    monitor='val_loss',
    patience=5,
    restore_best_weights=True
)

# Model checkpoint
keras.callbacks.ModelCheckpoint(
    filepath='model_{epoch:02d}.keras',
    save_best_only=True,
    monitor='val_loss'
)

# Learning rate scheduler
keras.callbacks.ReduceLROnPlateau(
    monitor='val_loss',
    factor=0.1,
    patience=3
)

# TensorBoard
keras.callbacks.TensorBoard(log_dir='./logs')

# Evaluate on test data
loss, accuracy = model.evaluate(x_test, y_test)

# Predict
predictions = model.predict(x_test)

# Predict single sample
prediction = model.predict(x_test[0:1])

# Predict classes
class_predictions = predictions.argmax(axis=1)

# Print model summary
model.summary()

# Get model config
config = model.get_config()

# Count parameters
total_params = model.count_params()

# Save entire model (Keras format)
model.save('model.keras')

# Save weights only
model.save_weights('weights.weights.h5')

# Save architecture only
json_config = model.to_json()
with open('model.json', 'w') as f:
    f.write(json_config)

# Load entire model
model = keras.models.load_model('model.keras')

# Load weights
model.load_weights('weights.weights.h5')

# Load from JSON
with open('model.json') as f:
    json_config = f.read()
model = keras.models.model_from_json(json_config)

# Normalization layer
normalization = layers.Normalization()
normalization.adapt(x_train)

# Rescaling
layers.Rescaling(1./255)

# Data augmentation
data_augmentation = keras.Sequential([
    layers.RandomFlip("horizontal"),
    layers.RandomRotation(0.1),
    layers.RandomZoom(0.1),
    layers.RandomContrast(0.1),
])

# Text vectorization
vectorize_layer = layers.TextVectorization(
    max_tokens=10000,
    output_mode='int',
    output_sequence_length=100
)
vectorize_layer.adapt(text_dataset)

# Get vocabulary
vocab = vectorize_layer.get_vocabulary()

import tensorflow as tf

# Create dataset
dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
dataset = dataset.shuffle(buffer_size=1000)
dataset = dataset.batch(32)
dataset = dataset.prefetch(tf.data.AUTOTUNE)

# Image dataset from directory
train_ds = keras.utils.image_dataset_from_directory(
    'data/train',
    image_size=(224, 224),
    batch_size=32
)

# Load pretrained model
base_model = keras.applications.ResNet50(
    weights='imagenet',
    include_top=False,
    input_shape=(224, 224, 3)
)

# Freeze base model
base_model.trainable = False

# Add custom head
inputs = keras.Input(shape=(224, 224, 3))
x = base_model(inputs, training=False)
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(256, activation='relu')(x)
outputs = layers.Dense(10, activation='softmax')(x)

model = keras.Model(inputs, outputs)

# Unfreeze for fine-tuning
base_model.trainable = True

# Freeze early layers, train later layers
for layer in base_model.layers[:100]:
    layer.trainable = False

# Compile with lower learning rate
model.compile(
    optimizer=keras.optimizers.Adam(1e-5),
    loss='categorical_crossentropy',
    metrics=['accuracy']
)

keras.applications.VGG16()
keras.applications.VGG19()
keras.applications.ResNet50()
keras.applications.ResNet101()
keras.applications.InceptionV3()
keras.applications.MobileNetV2()
keras.applications.EfficientNetV2B0()
keras.applications.DenseNet121()