Deep Learning

# Deep Learning Neural Network Configuration Template
# Use this template to configure neural network architectures

# Model Architecture Configuration
model:
  name: "custom_neural_network"
  type: "sequential"  # sequential, functional, or subclass

  # Input Configuration
  input:
    shape: [224, 224, 3]  # For image classification
    dtype: "float32"
    preprocessing:
      normalize: true
      augment: true

  # Layer Definitions
  layers:
    # Convolutional Block 1
    - type: "Conv2D"
      filters: 32
      kernel_size: [3, 3]
      activation: "relu"
      padding: "same"
    - type: "BatchNormalization"
    - type: "MaxPooling2D"
      pool_size: [2, 2]
    - type: "Dropout"
      rate: 0.25

    # Convolutional Block 2
    - type: "Conv2D"
      filters: 64
      kernel_size: [3, 3]
      activation: "relu"
      padding: "same"
    - type: "BatchNormalization"
    - type: "MaxPooling2D"
      pool_size: [2, 2]
    - type: "Dropout"
      rate: 0.25

    # Convolutional Block 3
    - type: "Conv2D"
      filters: 128
      kernel_size: [3, 3]
      activation: "relu"
      padding: "same"
    - type: "BatchNormalization"
    - type: "MaxPooling2D"
      pool_size: [2, 2]
    - type: "Dropout"
      rate: 0.25

    # Dense Layers
    - type: "Flatten"
    - type: "Dense"
      units: 512
      activation: "relu"
    - type: "BatchNormalization"
    - type: "Dropout"
      rate: 0.5
    - type: "Dense"
      units: 10  # Number of classes
      activation: "softmax"

# Training Configuration
training:
  optimizer:
    name: "adam"
    learning_rate: 0.001
    beta_1: 0.9
    beta_2: 0.999
    epsilon: 1e-07

  loss: "categorical_crossentropy"
  metrics:
    - "accuracy"
    - "precision"
    - "recall"
    - "f1_score"

  batch_size: 32
  epochs: 100

  # Learning Rate Schedule
  lr_schedule:
    type: "reduce_on_plateau"
    factor: 0.5
    patience: 5
    min_lr: 1e-7

  # Early Stopping
  early_stopping:
    monitor: "val_loss"
    patience: 10
    restore_best_weights: true

  # Checkpointing
  checkpoint:
    filepath: "models/best_model.h5"
    monitor: "val_accuracy"
    save_best_only: true
    mode: "max"

# Data Augmentation
augmentation:
  enabled: true
  params:
    rotation_range: 20
    width_shift_range: 0.2
    height_shift_range: 0.2
    horizontal_flip: true
    vertical_flip: false
    zoom_range: 0.2
    shear_range: 0.2
    fill_mode: "nearest"

# Hardware Configuration
hardware:
  device: "auto"  # auto, cpu, gpu
  mixed_precision: true
  multi_gpu: false
  num_workers: 4

# Logging and Monitoring
logging:
  tensorboard:
    enabled: true
    log_dir: "logs/tensorboard"
  wandb:
    enabled: false
    project: "deep-learning-project"
  mlflow:
    enabled: true
    tracking_uri: "mlruns"

#!/usr/bin/env python3
"""
Deep Learning Training Script
Supports PyTorch and TensorFlow/Keras frameworks
"""

import os
import yaml
import argparse
from pathlib import Path
from datetime import datetime


def load_config(config_path: str) -> dict:
    """Load YAML configuration file."""
    with open(config_path, 'r') as f:
        return yaml.safe_load(f)


def create_pytorch_model(config: dict):
    """Create PyTorch neural network from config."""
    import torch
    import torch.nn as nn

    class DynamicNet(nn.Module):
        def __init__(self, layer_configs):
            super().__init__()
            self.layers = nn.ModuleList()

            for layer_cfg in layer_configs:
                layer_type = layer_cfg['type']

                if layer_type == 'Conv2D':
                    self.layers.append(nn.Conv2d(
                        in_channels=layer_cfg.get('in_channels', 3),
                        out_channels=layer_cfg['filters'],
                        kernel_size=tuple(layer_cfg['kernel_size']),
                        padding=layer_cfg.get('padding', 'same')
                    ))
                    if layer_cfg.get('activation') == 'relu':
                        self.layers.append(nn.ReLU())

                elif layer_type == 'BatchNormalization':
                    # Batch norm channels inferred from previous conv
                    self.layers.append(nn.BatchNorm2d(layer_cfg.get('num_features', 64)))

                elif layer_type == 'MaxPooling2D':
                    self.layers.append(nn.MaxPool2d(
                        kernel_size=tuple(layer_cfg['pool_size'])
                    ))

                elif layer_type == 'Dropout':
                    self.layers.append(nn.Dropout(layer_cfg['rate']))

                elif layer_type == 'Flatten':
                    self.layers.append(nn.Flatten())

                elif layer_type == 'Dense':
                    self.layers.append(nn.Linear(
                        in_features=layer_cfg.get('in_features', 512),
                        out_features=layer_cfg['units']
                    ))
                    if layer_cfg.get('activation') == 'relu':
                        self.layers.append(nn.ReLU())
                    elif layer_cfg.get('activation') == 'softmax':
                        self.layers.append(nn.Softmax(dim=1))

        def forward(self, x):
            for layer in self.layers:
                x = layer(x)
            return x

    return DynamicNet(config['model']['layers'])


def create_keras_model(config: dict):
    """Create Keras/TensorFlow model from config."""
    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras import layers

    model = keras.Sequential()
    input_shape = tuple(config['model']['input']['shape'])

    first_layer = True
    for layer_cfg in config['model']['layers']:
        layer_type = layer_cfg['type']

        if layer_type == 'Conv2D':
            kwargs = {
                'filters': layer_cfg['filters'],
                'kernel_size': tuple(layer_cfg['kernel_size']),
                'activation': layer_cfg.get('activation'),
                'padding': layer_cfg.get('padding', 'valid')
            }
            if first_layer:
                kwargs['input_shape'] = input_shape
                first_layer = False
            model.add(layers.Conv2D(**kwargs))

        elif layer_type == 'BatchNormalization':
            model.add(layers.BatchNormalization())

        elif layer_type == 'MaxPooling2D':
            model.add(layers.MaxPooling2D(pool_size=tuple(layer_cfg['pool_size'])))

        elif layer_type == 'Dropout':
            model.add(layers.Dropout(layer_cfg['rate']))

        elif layer_type == 'Flatten':
            model.add(layers.Flatten())

        elif layer_type == 'Dense':
            model.add(layers.Dense(
                units=layer_cfg['units'],
                activation=layer_cfg.get('activation')
            ))

    return model


def train_pytorch(model, train_loader, val_loader, config: dict):
    """Train PyTorch model."""
    import torch
    import torch.nn as nn
    import torch.optim as optim

    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model = model.to(device)

    # Setup optimizer
    opt_config = config['training']['optimizer']
    optimizer = optim.Adam(
        model.parameters(),
        lr=opt_config['learning_rate'],
        betas=(opt_config['beta_1'], opt_config['beta_2']),
        eps=opt_config['epsilon']
    )

    # Loss function
    criterion = nn.CrossEntropyLoss()

    # Training loop
    epochs = config['training']['epochs']
    best_val_loss = float('inf')
    patience_counter = 0

    for epoch in range(epochs):
        model.train()
        train_loss = 0.0

        for batch_idx, (data, target) in enumerate(train_loader):
            data, target = data.to(device), target.to(device)

            optimizer.zero_grad()
            output = model(data)
            loss = criterion(output, target)
            loss.backward()
            optimizer.step()

            train_loss += loss.item()

        # Validation
        model.eval()
        val_loss = 0.0
        correct = 0

        with torch.no_grad():
            for data, target in val_loader:
                data, target = data.to(device), target.to(device)
                output = model(data)
                val_loss += criterion(output, target).item()
                pred = output.argmax(dim=1, keepdim=True)
                correct += pred.eq(target.view_as(pred)).sum().item()

        val_loss /= len(val_loader)
        accuracy = 100. * correct / len(val_loader.dataset)

        print(f'Epoch {epoch+1}/{epochs}')
        print(f'  Train Loss: {train_loss/len(train_loader):.4f}')
        print(f'  Val Loss: {val_loss:.4f}, Accuracy: {accuracy:.2f}%')

        # Early stopping
        if val_loss < best_val_loss:
            best_val_loss = val_loss
            patience_counter = 0
            torch.save(model.state_dict(), 'best_model.pt')
        else:
            patience_counter += 1
            if patience_counter >= config['training']['early_stopping']['patience']:
                print(f'Early stopping at epoch {epoch+1}')
                break

    return model


def train_keras(model, train_data, val_data, config: dict):
    """Train Keras/TensorFlow model."""
    from tensorflow import keras

    # Compile model
    opt_config = config['training']['optimizer']
    optimizer = keras.optimizers.Adam(
        learning_rate=opt_config['learning_rate'],
        beta_1=opt_config['beta_1'],
        beta_2=opt_config['beta_2'],
        epsilon=opt_config['epsilon']
    )

    model.compile(
        optimizer=optimizer,
        loss=config['training']['loss'],
        metrics=config['training']['metrics'][:2]  # accuracy, precision
    )

    # Callbacks
    callbacks = []

    # Early stopping
    es_config = config['training']['early_stopping']
    callbacks.append(keras.callbacks.EarlyStopping(
        monitor=es_config['monitor'],
        patience=es_config['patience'],
        restore_best_weights=es_config['restore_best_weights']
    ))

    # Learning rate reduction
    lr_config = config['training']['lr_schedule']
    callbacks.append(keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss',
        factor=lr_config['factor'],
        patience=lr_config['patience'],
        min_lr=lr_config['min_lr']
    ))

    # Model checkpoint
    ckpt_config = config['training']['checkpoint']
    os.makedirs(os.path.dirname(ckpt_config['filepath']), exist_ok=True)
    callbacks.append(keras.callbacks.ModelCheckpoint(
        filepath=ckpt_config['filepath'],
        monitor=ckpt_config['monitor'],
        save_best_only=ckpt_config['save_best_only'],
        mode=ckpt_config['mode']
    ))

    # Train
    history = model.fit(
        train_data,
        validation_data=val_data,
        epochs=config['training']['epochs'],
        batch_size=config['training']['batch_size'],
        callbacks=callbacks
    )

    return model, history


def main():
    parser = argparse.ArgumentParser(description='Train Deep Learning Model')
    parser.add_argument('--config', type=str, required=True, help='Path to config YAML')
    parser.add_argument('--framework', type=str, default='keras',
                       choices=['pytorch', 'keras'], help='DL framework')
    parser.add_argument('--data-dir', type=str, default='data', help='Data directory')
    parser.add_argument('--output-dir', type=str, default='outputs', help='Output directory')

    args = parser.parse_args()

    # Load configuration
    config = load_config(args.config)
    print(f"Loaded configuration from {args.config}")

    # Create output directory
    timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
    output_dir = Path(args.output_dir) / timestamp
    output_dir.mkdir(parents=True, exist_ok=True)

    print(f"\n{'='*50}")
    print(f"Deep Learning Training Pipeline")
    print(f"Framework: {args.framework.upper()}")
    print(f"Model: {config['model']['name']}")
    print(f"Output: {output_dir}")
    print(f"{'='*50}\n")

    if args.framework == 'pytorch':
        model = create_pytorch_model(config)
        print(f"Created PyTorch model")
        # Note: Add data loading logic for your specific use case
        print("Training with PyTorch...")
    else:
        model = create_keras_model(config)
        model.summary()
        print("Training with Keras/TensorFlow...")

    print("\n[SUCCESS] Training pipeline initialized!")
    print(f"Epochs: {config['training']['epochs']}")
    print(f"Batch Size: {config['training']['batch_size']}")
    print(f"Learning Rate: {config['training']['optimizer']['learning_rate']}")


if __name__ == '__main__':
    main()