Understanding TensorFlow

import tensorflow as tf

# TensorFlow 2.x uses eager execution by default (operations execute immediately)
# But the graph concept still exists underneath

# Building a simple computation
x = tf.constant([[1, 2], [3, 4]], dtype=tf.float32)
y = tf.constant([[5, 6], [7, 8]], dtype=tf.float32)

# Operations form a graph behind the scenes
z = tf.matmul(x, y)  # Matrix multiplication
w = tf.reduce_mean(z)  # Average of all elements

print("Result matrix:", z.numpy())
print("Average value:", w.numpy())

# Using tf.function to explicitly create a graph
@tf.function  # This decorator converts the function to a graph
def graph_operations(x, y):
    z = tf.matmul(x, y)
    w = tf.reduce_mean(z)
    return z, w

# This call is executed as a graph
result_matrix, average = graph_operations(x, y)
print("Graph execution results:", result_matrix.numpy(), average.numpy())
                            

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
import numpy as np

# 1. Prepare data
# Generate synthetic data for demonstration
X_train = np.random.random((1000, 20))  # 1000 samples, 20 features
y_train = np.random.randint(2, size=(1000, 1))  # Binary targets
X_test = np.random.random((200, 20))  # 200 test samples
y_test = np.random.randint(2, size=(200, 1))  # Test targets

# 2. Define model
model = Sequential([
    Dense(64, activation='relu', input_shape=(20,)),
    Dense(32, activation='relu'),
    Dense(16, activation='relu'),
    Dense(1, activation='sigmoid')
])

# 3. Compile model
model.compile(
    optimizer='adam',  # Adaptive optimization algorithm
    loss='binary_crossentropy',  # Loss function for binary classification
    metrics=['accuracy']  # Metrics to track during training/testing
)

# Print model summary
model.summary()

# 4. Fit model
history = model.fit(
    X_train, y_train,
    epochs=20,  # Number of passes through the dataset
    batch_size=32,  # Samples per gradient update
    validation_split=0.2,  # Use 20% of training data for validation
    verbose=1  # Show progress bar
)

# 5. Evaluate model
test_loss, test_accuracy = model.evaluate(X_test, y_test)
print(f"Test accuracy: {test_accuracy:.4f}")

# 6. Make predictions
predictions = model.predict(X_test)
                            

import tensorflow as tf
from tensorflow.keras.callbacks import ModelCheckpoint, EarlyStopping, ReduceLROnPlateau

# Create callbacks
callbacks = [
    # Save the best model based on validation accuracy
    ModelCheckpoint(
        filepath='best_model.h5',
        monitor='val_accuracy',
        save_best_only=True,
        verbose=1
    ),
    
    # Stop training when validation loss stops improving
    EarlyStopping(
        monitor='val_loss',
        patience=10,     # Number of epochs with no improvement
        restore_best_weights=True,
        verbose=1
    ),
    
    # Reduce learning rate when validation loss plateaus
    ReduceLROnPlateau(
        monitor='val_loss',
        factor=0.2,      # Factor by which to reduce learning rate
        patience=5,      # Number of epochs with no improvement
        min_lr=1e-6,     # Minimum learning rate
        verbose=1
    )
]

# Use callbacks during training
model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_split=0.2,
    callbacks=callbacks
)