PyTorch vs TensorFlow (2026):
1. PyTorch
   ✅ Dynamic computation graphs
   ✅ Pythonic, easy to debug
   ✅ Strong in research
   ✅ Transfer learning friendly
   ❌ Slower deployment

2. TensorFlow
   ✅ Static computation graphs
   ✅ Production-ready (TF Serving)
   ✅ Ecosystem (TFX, TFLite)
   ✅ Strong in deployment
   ❌ Steeper learning curve

3. Keras
   ✅ High-level, beginner-friendly
   ✅ Runs on TensorFlow
   ✅ Fast prototyping
   ❌ Limited flexibility

How to Choose a Framework:
1. For Research → PyTorch
2. For Production → TensorFlow
3. For Beginners → Keras
4. For Performance → JAX
5. For Mobile → Caffe2 / TFLite

Key Questions to Ask:
- What is your goal? (Research, Production, Learning)
- What is your team's expertise?
- What is your deployment target?
- What is your hardware?

# Standard Deep Learning Imports
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import torch
import tensorflow as tf
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

# Deep Learning Specific
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, Dataset
from tensorflow.keras import layers, models

# Data Visualization with Matplotlib & Seaborn
import matplotlib.pyplot as plt
import seaborn as sns

# Plot training history
plt.figure(figsize=(10, 6))
plt.plot(history.history['loss'], label='Training Loss')
plt.plot(history.history['val_loss'], label='Validation Loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.title('Training History')
plt.show()

# Confusion Matrix with Seaborn
sns.heatmap(confusion_matrix, annot=True, fmt='d', cmap='Blues')
plt.title('Confusion Matrix')
plt.show()

Free Platforms for Deep Learning:
1. Google Colab
   ✅ Free GPU (T4)
   ✅ 12-hour sessions
   ✅ Pre-installed libraries
   ✅ Easy collaboration
   ❌ Limited memory

2. Kaggle
   ✅ Free GPU
   ✅ 30-hour/week limit
   ✅ Datasets and competitions
   ✅ Notebook environment
   ❌ Less flexibility

3. Hugging Face Spaces
   ✅ Free hosting
   ✅ Share models
   ✅ Community
   ❌ Limited resources

Enterprise Platforms Comparison:
1. AWS SageMaker
   ✅ Fully managed
   ✅ Auto-scaling
   ✅ Integrated with AWS
   ❌ Costly

2. GCP AI Platform
   ✅ Fully managed
   ✅ TensorFlow optimized
   ✅ Integrated with GCP
   ❌ Learning curve

3. Azure ML
   ✅ Fully managed
   ✅ Microsoft ecosystem
   ✅ Enterprise support
   ❌ Can be complex

4. Databricks
   ✅ Unified analytics
   ✅ Apache Spark integration
   ✅ Great for big data
   ❌ Costly

Deep Learning Deployment Pipeline:
1. Train Model
   → Using PyTorch or TensorFlow
   → Save model weights

2. Optimize Model
   → Convert to ONNX
   → Quantize (INT8/FP16)
   → Optimize for target hardware

3. Containerize
   → Create Docker image
   → Include dependencies
   → Include model

4. Deploy
   → Cloud (AWS/GCP/Azure)
   → On-premise
   → Edge (Mobile/IoT)

5. Serve
   → REST API (FastAPI)
   → gRPC (TF Serving)
   → Web UI (Gradio, Streamlit)

Model Optimization Techniques:
1. Pruning
   → Remove less important weights
   → Reduces model size
   → Minimal accuracy loss

2. Quantization
   → Convert FP32 to INT8
   → Smaller model, faster inference
   → Good for mobile/edge

3. Knowledge Distillation
   → Train smaller model from larger
   → Maintains accuracy
   → Better for deployment

4. ONNX Optimization
   → Convert to ONNX
   → Use ONNX Runtime
   → Cross-platform inference