Keras

Keras is an open-source neural network library written in Python. It acts as a high-level API (Application Programming Interface) for building and training deep learning models. Originally developed as an independent project by François Chollet, Keras has since been integrated into TensorFlow 2.0 as its official high-level API, making it the primary way to interact with TensorFlow.

Key Characteristics and Features:

1. User-friendliness: Keras is designed for human engineers, emphasizing ease of use, readability, and intuition. It provides a simple and consistent API for common deep learning tasks.
2. Modularity: A Keras model is a composition of standalone, fully configurable modules (neural layers, cost functions, optimizers, activation functions, etc.) that can be plugged together with minimal restrictions.
3. Extensibility: It's easy to add new modules (e.g., custom loss functions, layers, or metrics) as classes and functions.
4. Rapid Prototyping: Due to its user-friendly and modular nature, Keras enables quick experimentation and rapid iteration, which is crucial in deep learning research and development.
5. Backend Agnosticism (Historically): While now primarily integrated with TensorFlow, Keras was initially designed to run on top of multiple backend deep learning engines like TensorFlow, Theano, and CNTK. This abstraction allowed developers to switch between backends with minimal code changes.

Core Components:

- Models: Keras offers two main ways to build models:
- `Sequential` API: For simple, layer-by-layer stacks of neural networks.
- `Functional` API: For more complex models, including multi-input/multi-output models, arbitrary graph topologies, and models with shared layers.
- Layers: The fundamental building blocks of neural networks. Keras provides a wide range of pre-built layers (e.g., `Dense`, `Conv2D`, `LSTM`, `Dropout`, `BatchNormalization`).
- Optimizers: Algorithms used to adjust the weights of the neural network during training to minimize the loss function (e.g., `Adam`, `SGD`, `RMSprop`).
- Loss Functions: Functions that measure the difference between predicted values and actual values (e.g., `categorical_crossentropy`, `mean_squared_error`).
- Metrics: Functions used to evaluate the performance of a model during training and testing (e.g., `accuracy`, `precision`, `recall`).

Use Cases:
Keras is widely used for building and training various types of neural networks, including:
- Feedforward Neural Networks (FNNs)
- Convolutional Neural Networks (CNNs) for computer vision tasks
- Recurrent Neural Networks (RNNs) for sequential data and natural language processing (NLP)
- Generative Adversarial Networks (GANs)
- Autoencoders and more.

In essence, Keras provides an accessible and powerful interface for building, training, and deploying deep learning models, making deep learning more approachable for a broad audience.

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
import numpy as np

 1. Prepare Data
 We'll create some dummy data for a simple binary classification task
X = np.random.rand(1000, 10).astype(np.float32)  1000 samples, 10 features
y = (np.sum(X[:, :5], axis=1) > 2.5).astype(np.int32)  Target based on first 5 features

 Split data into training and testing sets
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

 2. Build the Model (Sequential API)
 A simple feedforward neural network
model = keras.Sequential([
    layers.Input(shape=(10,)),  Input layer specifying the input shape
    layers.Dense(64, activation='relu'),  Hidden layer with 64 neurons and ReLU activation
    layers.Dropout(0.3),  Dropout layer for regularization
    layers.Dense(32, activation='relu'),  Another hidden layer with 32 neurons
    layers.Dense(1, activation='sigmoid')  Output layer with 1 neuron (binary classification) and sigmoid activation
])

 3. Compile the Model
 Specify optimizer, loss function, and metrics to monitor
model.compile(
    optimizer='adam',
    loss='binary_crossentropy',
    metrics=['accuracy']
)

 Display model summary
print("\n--- Model Summary ---")
model.summary()

 4. Train the Model
print("\n--- Training Model ---")
history = model.fit(
    X_train,
    y_train,
    epochs=10,  Number of times to iterate over the entire dataset
    batch_size=32,  Number of samples per gradient update
    validation_split=0.1,  Fraction of training data to be used as validation data
    verbose=1  Display training progress
)

 5. Evaluate the Model
print("\n--- Evaluating Model ---")
loss, accuracy = model.evaluate(X_test, y_test, verbose=0)
print(f"Test Loss: {loss:.4f}")
print(f"Test Accuracy: {accuracy:.4f}")

 6. Make Predictions
print("\n--- Making Predictions ---")
some_new_data = np.random.rand(5, 10).astype(np.float32)
predictions = model.predict(some_new_data)

print("Predictions (probabilities):\n", predictions)
 To get binary class labels (0 or 1)
predicted_classes = (predictions > 0.5).astype(int)
print("Predicted classes:\n", predicted_classes)

 Example of using the Functional API for a slightly more complex model (optional, for demonstration)
 This is just to show an alternative model building approach
 input_tensor = keras.Input(shape=(10,))
 x = layers.Dense(64, activation='relu')(input_tensor)
 x = layers.Dropout(0.3)(x)
 output_tensor = layers.Dense(1, activation='sigmoid')(x)
 functional_model = keras.Model(inputs=input_tensor, outputs=output_tensor)
 functional_model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
 print("\n--- Functional Model Summary ---")
 functional_model.summary()