ONNX

graph TD
    A[ONNX] --> B[Model Representation]
    A --> C[Operators]
    A --> D[Interoperability]
    A --> E[Runtime]
    A --> F[Ecosystem]
    A --> G[Tools]

    B --> B1[Computational Graph]
    B --> B2[Model Protobuf]
    B --> B3[Versioning]
    B --> B4[Metadata]

    C --> C1[Standard Operators]
    C --> C2[Custom Operators]
    C --> C3[Operator Sets]
    C --> C4[Extensibility]

    D --> D1[Framework Interop]
    D --> D2[Hardware Acceleration]
    D --> D3[Cross-Platform]
    D --> D4[Cloud Integration]

    E --> E1[ONNX Runtime]
    E --> E2[Execution Providers]
    E --> E3[Optimization]
    E --> E4[Quantization]

    F --> F1[Model Zoo]
    F --> F2[Converter Tools]
    F --> F3[Validation Tools]
    F --> F4[Community]

    G --> G1[Conversion Tools]
    G --> G2[Visualization Tools]
    G --> G3[Optimization Tools]
    G --> G4[Deployment Tools]

    style A fill:#009688,stroke:#333
    style B fill:#4CAF50,stroke:#333
    style C fill:#2196F3,stroke:#333
    style D fill:#9C27B0,stroke:#333
    style E fill:#FF9800,stroke:#333
    style F fill:#F44336,stroke:#333
    style G fill:#607D8B,stroke:#333

# Basic ONNX example
import numpy as np
import onnx
from onnx import helper, TensorProto
import onnxruntime as ort
import matplotlib.pyplot as plt

print("Basic ONNX Example...")

# 1. Create a simple ONNX model
print("\n1. Creating a Simple ONNX Model...")
# Create inputs (ValueInfoProto)
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [None, 2])
A = helper.make_tensor_value_info('A', TensorProto.FLOAT, [2, 2])
B = helper.make_tensor_value_info('B', TensorProto.FLOAT, [2])

# Create outputs (ValueInfoProto)
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [None, 2])

# Create a node (NodeProto)
node_def = helper.make_node(
    'Gemm',  # Operation type
    ['X', 'A', 'B'],  # Inputs
    ['Y'],  # Outputs
    alpha=1.0,
    beta=1.0,
    transB=1
)

# Create the graph (GraphProto)
graph_def = helper.make_graph(
    [node_def],  # Nodes
    'linear-regression',  # Name
    [X, A, B],  # Inputs
    [Y]  # Outputs
)

# Create the model (ModelProto)
model_def = helper.make_model(graph_def, producer_name='onnx-example')

# Save the model
onnx.save(model_def, 'linear_regression.onnx')
print("ONNX model saved to 'linear_regression.onnx'")

# 2. Load and inspect the model
print("\n2. Loading and Inspecting the Model...")
# Load the model
model = onnx.load('linear_regression.onnx')

# Check model validity
try:
    onnx.checker.check_model(model)
    print("Model is valid!")
except onnx.checker.ValidationError as e:
    print(f"Model is invalid: {e}")

# Print model information
print("\nModel Information:")
print(f"IR Version: {model.ir_version}")
print(f"Producer Name: {model.producer_name}")
print(f"Opset Import: {model.opset_import}")

# Print graph information
print("\nGraph Information:")
graph = model.graph
print(f"Name: {graph.name}")
print(f"Inputs: {len(graph.input)}")
for i, input in enumerate(graph.input):
    print(f"  Input {i}: {input.name} ({input.type.tensor_type.elem_type})")
print(f"Outputs: {len(graph.output)}")
for i, output in enumerate(graph.output):
    print(f"  Output {i}: {output.name} ({output.type.tensor_type.elem_type})")
print(f"Nodes: {len(graph.node)}")
for i, node in enumerate(graph.node):
    print(f"  Node {i}: {node.op_type} - Inputs: {node.input}, Outputs: {node.output}")

# 3. Run inference with ONNX Runtime
print("\n3. Running Inference with ONNX Runtime...")
# Create ONNX Runtime session
sess_options = ort.SessionOptions()
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

# Create inference session
ort_session = ort.InferenceSession('linear_regression.onnx', sess_options)

# Prepare input data
X_test = np.array([[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]], dtype=np.float32)
A_test = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
B_test = np.array([0.5, 0.5], dtype=np.float32)

# Run inference
inputs = {
    'X': X_test,
    'A': A_test,
    'B': B_test
}
outputs = ort_session.run(['Y'], inputs)

Y_pred = outputs[0]
print(f"Input X:\n{X_test}")
print(f"Weight A:\n{A_test}")
print(f"Bias B: {B_test}")
print(f"Output Y:\n{Y_pred}")

# Verify with NumPy
Y_expected = np.dot(X_test, A_test.T) + B_test
print(f"Expected output:\n{Y_expected}")
print(f"Results match: {np.allclose(Y_pred, Y_expected)}")

# 4. Visualize the model
print("\n4. Visualizing the Model...")
# This would typically use a visualization tool like Netron
print("Model visualization would be displayed using Netron or similar tools")
print("You can view the model at: https://netron.app")

# 5. Model optimization
print("\n5. Model Optimization...")
# Create optimized model
optimized_model_path = 'linear_regression_optimized.onnx'
sess_options = ort.SessionOptions()
sess_options.optimized_model_filepath = optimized_model_path
sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

# Create session to trigger optimization
ort_session = ort.InferenceSession('linear_regression.onnx', sess_options)

print(f"Optimized model saved to '{optimized_model_path}'")

# Compare performance
def benchmark_session(model_path, input_data, n_runs=100):
    """Benchmark ONNX Runtime session"""
    sess_options = ort.SessionOptions()
    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
    session = ort.InferenceSession(model_path, sess_options)

    # Warm-up
    for _ in range(10):
        session.run(['Y'], input_data)

    # Benchmark
    import time
    start_time = time.time()
    for _ in range(n_runs):
        session.run(['Y'], input_data)
    elapsed_time = time.time() - start_time

    return elapsed_time / n_runs

# Benchmark original and optimized models
input_data = {
    'X': X_test,
    'A': A_test,
    'B': B_test
}

original_time = benchmark_session('linear_regression.onnx', input_data)
optimized_time = benchmark_session(optimized_model_path, input_data)

print(f"Original model average time: {original_time:.6f} seconds")
print(f"Optimized model average time: {optimized_time:.6f} seconds")
print(f"Speedup: {original_time/optimized_time:.2f}x")

# 6. Model conversion example
print("\n6. Model Conversion Example...")
# This example shows how to convert from a framework to ONNX
# Here we'll create a simple model and convert it

# Create a simple PyTorch model for conversion
try:
    import torch
    import torch.nn as nn

    print("PyTorch available, demonstrating model conversion...")

    # Define a simple PyTorch model
    class SimpleModel(nn.Module):
        def __init__(self):
            super(SimpleModel, self).__init__()
            self.linear = nn.Linear(2, 2)

        def forward(self, x):
            return self.linear(x)

    # Create model instance
    pytorch_model = SimpleModel()
    pytorch_model.eval()

    # Create dummy input
    dummy_input = torch.randn(1, 2)

    # Export to ONNX
    onnx_model_path = 'pytorch_model.onnx'
    torch.onnx.export(
        pytorch_model,
        dummy_input,
        onnx_model_path,
        export_params=True,
        opset_version=13,
        do_constant_folding=True,
        input_names=['input'],
        output_names=['output'],
        dynamic_axes={
            'input': {0: 'batch_size'},
            'output': {0: 'batch_size'}
        }
    )

    print(f"PyTorch model converted to ONNX and saved to '{onnx_model_path}'")

    # Load and test the converted model
    ort_session = ort.InferenceSession(onnx_model_path)
    input_name = ort_session.get_inputs()[0].name
    output_name = ort_session.get_outputs()[0].name

    # Run inference
    torch_output = pytorch_model(dummy_input)
    onnx_output = ort_session.run([output_name], {input_name: dummy_input.numpy()})[0]

    print(f"PyTorch output: {torch_output.detach().numpy()}")
    print(f"ONNX output: {onnx_output}")
    print(f"Results match: {np.allclose(torch_output.detach().numpy(), onnx_output, rtol=1e-3)}")

except ImportError:
    print("PyTorch not available, skipping model conversion example")
    print("In practice, you would use torch.onnx.export() to convert PyTorch models")

# 7. Working with operator sets
print("\n7. Working with Operator Sets...")
# Check available operator sets
print("Available operator sets in the model:")
for opset in model.opset_import:
    print(f"  Domain: {opset.domain}, Version: {opset.version}")

# Create a model with multiple operator sets
print("\nCreating a model with multiple operator sets...")

# Create a model with custom operator set
custom_opset = helper.make_opsetid("custom.domain", 1)
model_with_custom_ops = helper.make_model(
    graph_def,
    producer_name='onnx-custom-ops',
    opset_imports=[helper.make_opsetid("", 13), custom_opset]
)

# Save the model
onnx.save(model_with_custom_ops, 'model_with_custom_ops.onnx')
print("Model with custom operator set saved")

# 8. Model metadata
print("\n8. Model Metadata...")
# Add metadata to the model
model_with_metadata = onnx.load('linear_regression.onnx')

# Add metadata
model_with_metadata.metadata_props.extend([
    helper.make_metadata_prop(key="author", value="AI Researcher"),
    helper.make_metadata_prop(key="description", value="Simple linear regression model"),
    helper.make_metadata_prop(key="framework", value="ONNX"),
    helper.make_metadata_prop(key="version", value="1.0")
])

# Save the model with metadata
onnx.save(model_with_metadata, 'linear_regression_with_metadata.onnx')
print("Model with metadata saved")

# 9. Model validation
print("\n9. Model Validation...")
# Validate the model
try:
    onnx.checker.check_model(model_with_metadata)
    print("Model validation successful!")
except onnx.checker.ValidationError as e:
    print(f"Model validation failed: {e}")

# Validate with different opset versions
print("\nValidating with different opset versions...")
for opset_version in [11, 12, 13, 14]:
    try:
        # Create a model with specific opset version
        model_version = helper.make_model(
            graph_def,
            producer_name='onnx-version-test',
            opset_imports=[helper.make_opsetid("", opset_version)]
        )
        onnx.checker.check_model(model_version)
        print(f"Opset version {opset_version}: Valid")
    except onnx.checker.ValidationError as e:
        print(f"Opset version {opset_version}: Invalid - {e}")
    except Exception as e:
        print(f"Opset version {opset_version}: Error - {e}")

# 10. Working with tensors
print("\n10. Working with Tensors...")
# Create a model with initializers (tensors)
print("Creating a model with initializers...")

# Create tensors (initializers)
A_tensor = helper.make_tensor(
    name='A',
    data_type=TensorProto.FLOAT,
    dims=[2, 2],
    vals=A_test.flatten().tolist()
)

B_tensor = helper.make_tensor(
    name='B',
    data_type=TensorProto.FLOAT,
    dims=[2],
    vals=B_test.tolist()
)

# Create node
node_with_init = helper.make_node(
    'Gemm',
    ['X', 'A', 'B'],
    ['Y'],
    alpha=1.0,
    beta=1.0,
    transB=1
)

# Create graph with initializers
graph_with_init = helper.make_graph(
    [node_with_init],
    'linear-regression-with-init',
    [X],  # Only X is input, A and B are initializers
    [Y],
    [A_tensor, B_tensor]  # Initializers
)

# Create model
model_with_init = helper.make_model(graph_with_init, producer_name='onnx-init-example')
onnx.save(model_with_init, 'linear_regression_with_init.onnx')
print("Model with initializers saved")

# Test the model with initializers
ort_session = ort.InferenceSession('linear_regression_with_init.onnx')
input_name = ort_session.get_inputs()[0].name

# Run inference
X_test = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
outputs = ort_session.run(['Y'], {input_name: X_test})
Y_pred = outputs[0]

print(f"Input X:\n{X_test}")
print(f"Output Y:\n{Y_pred}")

# Verify with expected output
Y_expected = np.dot(X_test, A_test.T) + B_test
print(f"Expected output:\n{Y_expected}")
print(f"Results match: {np.allclose(Y_pred, Y_expected)}")

# Model conversion example with ONNX
import numpy as np
import onnx
import onnxruntime as ort
import matplotlib.pyplot as plt

print("\nModel Conversion Example...")

# 1. Convert from scikit-learn to ONNX
print("1. Converting scikit-learn Model to ONNX...")
try:
    from sklearn.linear_model import LogisticRegression
    from sklearn.datasets import make_classification
    from skl2onnx import convert_sklearn
    from skl2onnx.common.data_types import FloatTensorType

    # Create a synthetic dataset
    X, y = make_classification(n_samples=1000, n_features=4, n_classes=3, random_state=42)

    # Train a logistic regression model
    model = LogisticRegression(max_iter=1000, random_state=42)
    model.fit(X, y)

    print(f"Trained scikit-learn model with {X.shape[1]} features and {len(np.unique(y))} classes")

    # Convert to ONNX
    initial_type = [('float_input', FloatTensorType([None, X.shape[1]]))]
    onnx_model = convert_sklearn(model, initial_types=initial_type)

    # Save the ONNX model
    onnx.save(onnx_model, 'logistic_regression.onnx')
    print("scikit-learn model converted to ONNX and saved")

    # Test the converted model
    ort_session = ort.InferenceSession('logistic_regression.onnx')
    input_name = ort_session.get_inputs()[0].name
    output_name = ort_session.get_outputs()[0].name

    # Run inference
    sample_input = X[:5].astype(np.float32)
    skl_pred = model.predict(sample_input)
    skl_proba = model.predict_proba(sample_input)

    onnx_pred = ort_session.run([output_name], {input_name: sample_input})[0]
    onnx_proba = ort_session.run(None, {input_name: sample_input})[1]  # probabilities

    print(f"Sample input:\n{sample_input}")
    print(f"scikit-learn predictions: {skl_pred}")
    print(f"ONNX predictions: {onnx_pred.flatten()}")
    print(f"Predictions match: {np.array_equal(skl_pred, onnx_pred.flatten())}")

    print(f"scikit-learn probabilities:\n{skl_proba}")
    print(f"ONNX probabilities:\n{onnx_proba}")
    print(f"Probabilities match: {np.allclose(skl_proba, onnx_proba, rtol=1e-4)}")

except ImportError:
    print("scikit-learn or skl2onnx not available, skipping scikit-learn conversion example")

# 2. Convert from TensorFlow to ONNX
print("\n2. Converting TensorFlow Model to ONNX...")
try:
    import tensorflow as tf
    from tf2onnx import convert

    print("TensorFlow available, demonstrating model conversion...")

    # Create a simple TensorFlow model
    model = tf.keras.Sequential([
        tf.keras.layers.Dense(10, activation='relu', input_shape=(4,)),
        tf.keras.layers.Dense(3, activation='softmax')
    ])

    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy')

    # Train on synthetic data
    X, y = make_classification(n_samples=1000, n_features=4, n_classes=3, random_state=42)
    model.fit(X, y, epochs=10, batch_size=32, verbose=0)

    print("Trained TensorFlow model")

    # Convert to ONNX
    spec = (tf.TensorSpec((None, 4), tf.float32, name="input"),
            tf.TensorSpec((None, 3), tf.float32, name="output"))
    output_path = "tf_model.onnx"

    model_proto, _ = convert.from_keras(model, input_signature=spec, opset=13)
    with open(output_path, "wb") as f:
        f.write(model_proto.SerializeToString())

    print(f"TensorFlow model converted to ONNX and saved to '{output_path}'")

    # Test the converted model
    ort_session = ort.InferenceSession(output_path)
    input_name = ort_session.get_inputs()[0].name
    output_name = ort_session.get_outputs()[0].name

    # Run inference
    sample_input = X[:5].astype(np.float32)
    tf_pred = model.predict(sample_input)
    onnx_pred = ort_session.run([output_name], {input_name: sample_input})[0]

    print(f"Sample input:\n{sample_input}")
    print(f"TensorFlow predictions:\n{tf_pred}")
    print(f"ONNX predictions:\n{onnx_pred}")
    print(f"Predictions match: {np.allclose(tf_pred, onnx_pred, rtol=1e-4)}")

except ImportError:
    print("TensorFlow or tf2onnx not available, skipping TensorFlow conversion example")

# 3. Convert from PyTorch to ONNX (repeated for completeness)
print("\n3. Converting PyTorch Model to ONNX...")
try:
    import torch
    import torch.nn as nn

    print("PyTorch available, demonstrating model conversion...")

    # Define a simple PyTorch model
    class SimpleCNN(nn.Module):
        def __init__(self):
            super(SimpleCNN, self).__init__()
            self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
            self.relu = nn.ReLU()
            self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
            self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
            self.fc = nn.Linear(64 * 7 * 7, 10)

        def forward(self, x):
            x = self.conv1(x)
            x = self.relu(x)
            x = self.pool(x)
            x = self.conv2(x)
            x = self.relu(x)
            x = self.pool(x)
            x = x.view(x.size(0), -1)
            x = self.fc(x)
            return x

    # Create model instance
    pytorch_model = SimpleCNN()
    pytorch_model.eval()

    # Create dummy input (batch_size=1, channels=1, height=28, width=28)
    dummy_input = torch.randn(1, 1, 28, 28)

    # Export to ONNX
    onnx_model_path = 'pytorch_cnn.onnx'
    torch.onnx.export(
        pytorch_model,
        dummy_input,
        onnx_model_path,
        export_params=True,
        opset_version=13,
        do_constant_folding=True,
        input_names=['input'],
        output_names=['output'],
        dynamic_axes={
            'input': {0: 'batch_size'},
            'output': {0: 'batch_size'}
        }
    )

    print(f"PyTorch CNN model converted to ONNX and saved to '{onnx_model_path}'")

    # Load and test the converted model
    ort_session = ort.InferenceSession(onnx_model_path)
    input_name = ort_session.get_inputs()[0].name
    output_name = ort_session.get_outputs()[0].name

    # Run inference
    torch_output = pytorch_model(dummy_input)
    onnx_output = ort_session.run([output_name], {input_name: dummy_input.numpy()})[0]

    print(f"PyTorch output shape: {torch_output.shape}")
    print(f"ONNX output shape: {onnx_output.shape}")
    print(f"Results match: {np.allclose(torch_output.detach().numpy(), onnx_output, rtol=1e-3)}")

except ImportError:
    print("PyTorch not available, skipping PyTorch CNN conversion example")

# 4. Convert from Keras to ONNX
print("\n4. Converting Keras Model to ONNX...")
try:
    from tensorflow import keras
    from tensorflow.keras import layers
    import keras2onnx

    print("Keras available, demonstrating model conversion...")

    # Create a simple Keras model
    model = keras.Sequential([
        layers.Dense(64, activation='relu', input_shape=(20,)),
        layers.Dropout(0.2),
        layers.Dense(32, activation='relu'),
        layers.Dense(1, activation='sigmoid')
    ])

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

    # Train on synthetic data
    X = np.random.randn(1000, 20)
    y = np.random.randint(0, 2, size=(1000,))
    model.fit(X, y, epochs=5, batch_size=32, verbose=0)

    print("Trained Keras model")

    # Convert to ONNX
    onnx_model = keras2onnx.convert_keras(model, model.name)
    onnx_model_path = "keras_model.onnx"
    onnx.save(onnx_model, onnx_model_path)

    print(f"Keras model converted to ONNX and saved to '{onnx_model_path}'")

    # Test the converted model
    ort_session = ort.InferenceSession(onnx_model_path)
    input_name = ort_session.get_inputs()[0].name
    output_name = ort_session.get_outputs()[0].name

    # Run inference
    sample_input = X[:5].astype(np.float32)
    keras_pred = model.predict(sample_input)
    onnx_pred = ort_session.run([output_name], {input_name: sample_input})[0]

    print(f"Sample input shape: {sample_input.shape}")
    print(f"Keras predictions:\n{keras_pred}")
    print(f"ONNX predictions:\n{onnx_pred}")
    print(f"Predictions match: {np.allclose(keras_pred, onnx_pred, rtol=1e-4)}")

except ImportError:
    print("Keras or keras2onnx not available, skipping Keras conversion example")

# 5. Convert from XGBoost to ONNX
print("\n5. Converting XGBoost Model to ONNX...")
try:
    import xgboost as xgb
    from skl2onnx import convert_sklearn
    from skl2onnx.common.data_types import FloatTensorType

    print("XGBoost available, demonstrating model conversion...")

    # Create a synthetic dataset
    X, y = make_classification(n_samples=1000, n_features=10, n_classes=2, random_state=42)

    # Train an XGBoost model
    model = xgb.XGBClassifier(n_estimators=100, max_depth=3, random_state=42)
    model.fit(X, y)

    print("Trained XGBoost model")

    # Convert to ONNX
    initial_type = [('float_input', FloatTensorType([None, X.shape[1]]))]
    onnx_model = convert_sklearn(model, initial_types=initial_type)

    # Save the ONNX model
    onnx.save(onnx_model, 'xgboost_model.onnx')
    print("XGBoost model converted to ONNX and saved")

    # Test the converted model
    ort_session = ort.InferenceSession('xgboost_model.onnx')
    input_name = ort_session.get_inputs()[0].name
    output_name = ort_session.get_outputs()[0].name

    # Run inference
    sample_input = X[:5].astype(np.float32)
    xgb_pred = model.predict(sample_input)
    xgb_proba = model.predict_proba(sample_input)

    onnx_pred = ort_session.run([output_name], {input_name: sample_input})[0]
    onnx_proba = ort_session.run(None, {input_name: sample_input})[1]  # probabilities

    print(f"Sample input:\n{sample_input}")
    print(f"XGBoost predictions: {xgb_pred}")
    print(f"ONNX predictions: {onnx_pred.flatten()}")
    print(f"Predictions match: {np.array_equal(xgb_pred, onnx_pred.flatten())}")

    print(f"XGBoost probabilities:\n{xgb_proba}")
    print(f"ONNX probabilities:\n{onnx_proba}")
    print(f"Probabilities match: {np.allclose(xgb_proba, onnx_proba, rtol=1e-4)}")

except ImportError:
    print("XGBoost or skl2onnx not available, skipping XGBoost conversion example")

# ONNX Runtime optimization example
import numpy as np
import onnx
import onnxruntime as ort
import time
import matplotlib.pyplot as plt

print("\nONNX Runtime Optimization Example...")

# 1. Create a more complex model for optimization
print("1. Creating a Complex Model for Optimization...")
# This model will have multiple layers and operations

# Create input and output tensors
X = helper.make_tensor_value_info('X', TensorProto.FLOAT, [None, 10])
Y = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [None, 3])

# Create initializers (weights and biases)
np.random.seed(42)
W1 = np.random.randn(10, 20).astype(np.float32)
b1 = np.random.randn(20).astype(np.float32)
W2 = np.random.randn(20, 10).astype(np.float32)
b2 = np.random.randn(10).astype(np.float32)
W3 = np.random.randn(10, 3).astype(np.float32)
b3 = np.random.randn(3).astype(np.float32)

# Create tensors
W1_tensor = helper.make_tensor('W1', TensorProto.FLOAT, W1.shape, W1.flatten().tolist())
b1_tensor = helper.make_tensor('b1', TensorProto.FLOAT, b1.shape, b1.tolist())
W2_tensor = helper.make_tensor('W2', TensorProto.FLOAT, W2.shape, W2.flatten().tolist())
b2_tensor = helper.make_tensor('b2', TensorProto.FLOAT, b2.shape, b2.tolist())
W3_tensor = helper.make_tensor('W3', TensorProto.FLOAT, W3.shape, W3.flatten().tolist())
b3_tensor = helper.make_tensor('b3', TensorProto.FLOAT, b3.shape, b3.tolist())

# Create nodes
node1 = helper.make_node('Gemm', ['X', 'W1', 'b1'], ['hidden1'])
node2 = helper.make_node('Relu', ['hidden1'], ['hidden1_relu'])
node3 = helper.make_node('Gemm', ['hidden1_relu', 'W2', 'b2'], ['hidden2'])
node4 = helper.make_node('Relu', ['hidden2'], ['hidden2_relu'])
node5 = helper.make_node('Gemm', ['hidden2_relu', 'W3', 'b3'], ['Y'])

# Create graph
graph_def = helper.make_graph(
    [node1, node2, node3, node4, node5],
    'complex-model',
    [X],
    [Y],
    [W1_tensor, b1_tensor, W2_tensor, b2_tensor, W3_tensor, b3_tensor]
)

# Create model
model_def = helper.make_model(graph_def, producer_name='onnx-optimization-example')
onnx.save(model_def, 'complex_model.onnx')
print("Complex model saved to 'complex_model.onnx'")

# 2. Benchmark different optimization levels
print("\n2. Benchmarking Different Optimization Levels...")
# Create test data
X_test = np.random.randn(1000, 10).astype(np.float32)

# Define optimization levels
optimization_levels = [
    ('ORT_DISABLE_ALL', ort.GraphOptimizationLevel.ORT_DISABLE_ALL),
    ('ORT_ENABLE_BASIC', ort.GraphOptimizationLevel.ORT_ENABLE_BASIC),
    ('ORT_ENABLE_EXTENDED', ort.GraphOptimizationLevel.ORT_ENABLE_EXTENDED),
    ('ORT_ENABLE_ALL', ort.GraphOptimizationLevel.ORT_ENABLE_ALL)
]

times = []
throughputs = []

for name, level in optimization_levels:
    print(f"\nBenchmarking {name}...")

    # Create session with specific optimization level
    sess_options = ort.SessionOptions()
    sess_options.graph_optimization_level = level

    # Create session
    session = ort.InferenceSession('complex_model.onnx', sess_options)

    # Warm-up
    for _ in range(10):
        session.run(['Y'], {'X': X_test})

    # Benchmark
    n_runs = 100
    start_time = time.time()
    for _ in range(n_runs):
        session.run(['Y'], {'X': X_test})
    elapsed_time = time.time() - start_time

    avg_time = elapsed_time / n_runs
    throughput = len(X_test) / avg_time

    times.append(avg_time)
    throughputs.append(throughput)

    print(f"  Average time: {avg_time:.6f} seconds")
    print(f"  Throughput: {throughput:.2f} samples/second")

# Plot results
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.bar([name for name, _ in optimization_levels], times)
plt.title('Inference Time by Optimization Level')
plt.ylabel('Time (seconds)')
plt.xticks(rotation=45)

plt.subplot(1, 2, 2)
plt.bar([name for name, _ in optimization_levels], throughputs)
plt.title('Throughput by Optimization Level')
plt.ylabel('Samples/second')
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# 3. Execution providers comparison
print("\n3. Execution Providers Comparison...")
# Check available execution providers
providers = ort.get_available_providers()
print("Available execution providers:")
for i, provider in enumerate(providers):
    print(f"  {i+1}. {provider}")

# Benchmark different execution providers
provider_times = {}
provider_throughputs = {}

for provider in providers:
    print(f"\nBenchmarking {provider}...")

    try:
        # Create session with specific provider
        sess_options = ort.SessionOptions()
        sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

        # Create session
        session = ort.InferenceSession('complex_model.onnx', sess_options, providers=[provider])

        # Warm-up
        for _ in range(10):
            session.run(['Y'], {'X': X_test})

        # Benchmark
        n_runs = 100
        start_time = time.time()
        for _ in range(n_runs):
            session.run(['Y'], {'X': X_test})
        elapsed_time = time.time() - start_time

        avg_time = elapsed_time / n_runs
        throughput = len(X_test) / avg_time

        provider_times[provider] = avg_time
        provider_throughputs[provider] = throughput

        print(f"  Average time: {avg_time:.6f} seconds")
        print(f"  Throughput: {throughput:.2f} samples/second")

    except Exception as e:
        print(f"  Error: {e}")
        provider_times[provider] = float('nan')
        provider_throughputs[provider] = float('nan')

# Plot provider comparison
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
valid_providers = [p for p in providers if not np.isnan(provider_times[p])]
valid_times = [provider_times[p] for p in valid_providers]
plt.bar(valid_providers, valid_times)
plt.title('Inference Time by Execution Provider')
plt.ylabel('Time (seconds)')
plt.xticks(rotation=45)

plt.subplot(1, 2, 2)
valid_throughputs = [provider_throughputs[p] for p in valid_providers]
plt.bar(valid_providers, valid_throughputs)
plt.title('Throughput by Execution Provider')
plt.ylabel('Samples/second')
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# 4. Model quantization
print("\n4. Model Quantization...")
# Quantization can significantly improve performance on some hardware

# Create a quantized version of the model
try:
    from onnxruntime.quantization import quantize_dynamic, QuantType

    print("Creating quantized model...")

    # Quantize the model
    quantized_model_path = 'complex_model_quantized.onnx'
    quantize_dynamic(
        'complex_model.onnx',
        quantized_model_path,
        weight_type=QuantType.QUInt8
    )

    print(f"Quantized model saved to '{quantized_model_path}'")

    # Compare model sizes
    import os
    original_size = os.path.getsize('complex_model.onnx') / 1024
    quantized_size = os.path.getsize(quantized_model_path) / 1024

    print(f"Original model size: {original_size:.2f} KB")
    print(f"Quantized model size: {quantized_size:.2f} KB")
    print(f"Size reduction: {original_size/quantized_size:.2f}x")

    # Benchmark quantized model
    print("\nBenchmarking quantized model...")

    # Create sessions
    sess_options = ort.SessionOptions()
    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL

    original_session = ort.InferenceSession('complex_model.onnx', sess_options)
    quantized_session = ort.InferenceSession(quantized_model_path, sess_options)

    # Warm-up
    for _ in range(10):
        original_session.run(['Y'], {'X': X_test})
        quantized_session.run(['Y'], {'X': X_test})

    # Benchmark
    n_runs = 100

    # Original model
    start_time = time.time()
    for _ in range(n_runs):
        original_session.run(['Y'], {'X': X_test})
    original_time = (time.time() - start_time) / n_runs

    # Quantized model
    start_time = time.time()
    for _ in range(n_runs):
        quantized_session.run(['Y'], {'X': X_test})
    quantized_time = (time.time() - start_time) / n_runs

    print(f"Original model average time: {original_time:.6f} seconds")
    print(f"Quantized model average time: {quantized_time:.6f} seconds")
    print(f"Speedup: {original_time/quantized_time:.2f}x")

    # Compare accuracy
    print("\nComparing accuracy...")

    # Run inference on both models
    original_output = original_session.run(['Y'], {'X': X_test})[0]
    quantized_output = quantized_session.run(['Y'], {'X': X_test})[0]

    # Calculate maximum difference
    max_diff = np.max(np.abs(original_output - quantized_output))
    mean_diff = np.mean(np.abs(original_output - quantized_output))

    print(f"Maximum difference: {max_diff:.6f}")
    print(f"Mean difference: {mean_diff:.6f}")

    # Check if results are close
    results_close = np.allclose(original_output, quantized_output, rtol=1e-2, atol=1e-2)
    print(f"Results are close: {results_close}")

except ImportError:
    print("ONNX Runtime quantization tools not available, skipping quantization example")

# 5. Session options tuning
print("\n5. Session Options Tuning...")
# Explore different session options for performance tuning

# Create different session configurations
configurations = [
    ('Default', {}),
    ('Optimized', {
        'graph_optimization_level': ort.GraphOptimizationLevel.ORT_ENABLE_ALL,
        'execution_mode': ort.ExecutionMode.ORT_SEQUENTIAL
    }),
    ('Parallel', {
        'graph_optimization_level': ort.GraphOptimizationLevel.ORT_ENABLE_ALL,
        'execution_mode': ort.ExecutionMode.ORT_PARALLEL,
        'inter_op_num_threads': 4,
        'intra_op_num_threads': 2
    }),
    ('Optimized + Parallel', {
        'graph_optimization_level': ort.GraphOptimizationLevel.ORT_ENABLE_ALL,
        'execution_mode': ort.ExecutionMode.ORT_PARALLEL,
        'inter_op_num_threads': 4,
        'intra_op_num_threads': 4
    })
]

config_times = []
config_throughputs = []

for name, options in configurations:
    print(f"\nBenchmarking {name} configuration...")

    # Create session options
    sess_options = ort.SessionOptions()
    for key, value in options.items():
        setattr(sess_options, key, value)

    # Create session
    session = ort.InferenceSession('complex_model.onnx', sess_options)

    # Warm-up
    for _ in range(10):
        session.run(['Y'], {'X': X_test})

    # Benchmark
    n_runs = 100
    start_time = time.time()
    for _ in range(n_runs):
        session.run(['Y'], {'X': X_test})
    elapsed_time = time.time() - start_time

    avg_time = elapsed_time / n_runs
    throughput = len(X_test) / avg_time

    config_times.append(avg_time)
    config_throughputs.append(throughput)

    print(f"  Average time: {avg_time:.6f} seconds")
    print(f"  Throughput: {throughput:.2f} samples/second")

# Plot configuration comparison
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.bar([name for name, _ in configurations], config_times)
plt.title('Inference Time by Configuration')
plt.ylabel('Time (seconds)')
plt.xticks(rotation=45)

plt.subplot(1, 2, 2)
plt.bar([name for name, _ in configurations], config_throughputs)
plt.title('Throughput by Configuration')
plt.ylabel('Samples/second')
plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

# 6. Batch size optimization
print("\n6. Batch Size Optimization...")
# Test different batch sizes for optimal performance

batch_sizes = [1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
batch_times = []
batch_throughputs = []

for batch_size in batch_sizes:
    print(f"\nBenchmarking batch size {batch_size}...")

    # Create test data
    X_batch = np.random.randn(batch_size, 10).astype(np.float32)

    # Create session
    sess_options = ort.SessionOptions()
    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
    session = ort.InferenceSession('complex_model.onnx', sess_options)

    # Warm-up
    for _ in range(10):
        session.run(['Y'], {'X': X_batch})

    # Benchmark
    n_runs = 100
    start_time = time.time()
    for _ in range(n_runs):
        session.run(['Y'], {'X': X_batch})
    elapsed_time = time.time() - start_time

    avg_time = elapsed_time / n_runs
    throughput = batch_size / avg_time

    batch_times.append(avg_time)
    batch_throughputs.append(throughput)

    print(f"  Average time: {avg_time:.6f} seconds")
    print(f"  Throughput: {throughput:.2f} samples/second")

# Plot batch size optimization
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.plot(batch_sizes, batch_times, marker='o')
plt.title('Inference Time by Batch Size')
plt.xlabel('Batch Size')
plt.ylabel('Time (seconds)')
plt.xscale('log', base=2)
plt.grid(True)

plt.subplot(1, 2, 2)
plt.plot(batch_sizes, batch_throughputs, marker='o')
plt.title('Throughput by Batch Size')
plt.xlabel('Batch Size')
plt.ylabel('Samples/second')
plt.xscale('log', base=2)
plt.grid(True)

plt.tight_layout()
plt.show()

# Find optimal batch size
optimal_idx = np.argmax(batch_throughputs)
optimal_batch_size = batch_sizes[optimal_idx]
optimal_throughput = batch_throughputs[optimal_idx]

print(f"\nOptimal batch size: {optimal_batch_size}")
print(f"Optimal throughput: {optimal_throughput:.2f} samples/second")

# Model deployment example with ONNX
import numpy as np
import onnx
import onnxruntime as ort
import time
import json
from flask import Flask, request, jsonify

print("\nModel Deployment Example...")

# 1. Prepare a model for deployment
print("1. Preparing Model for Deployment...")

# We'll use the complex model created earlier
model_path = 'complex_model.onnx'

# Load and validate the model
model = onnx.load(model_path)
try:
    onnx.checker.check_model(model)
    print("Model is valid for deployment")
except onnx.checker.ValidationError as e:
    print(f"Model validation failed: {e}")
    # For this example, we'll proceed anyway

# Add deployment metadata
model.metadata_props.extend([
    helper.make_metadata_prop(key="task", value="classification"),
    helper.make_metadata_prop(key="framework", value="ONNX"),
    helper.make_metadata_prop(key="version", value="1.0"),
    helper.make_metadata_prop(key="description", value="Multi-layer neural network for classification"),
    helper.make_metadata_prop(key="input_shape", value="[batch_size, 10]"),
    helper.make_metadata_prop(key="output_shape", value="[batch_size, 3]"),
    helper.make_metadata_prop(key="author", value="AI Engineer"),
    helper.make_metadata_prop(key="license", value="MIT")
])

# Save the model with metadata
deployment_model_path = 'deployment_model.onnx'
onnx.save(model, deployment_model_path)
print(f"Model prepared for deployment and saved to '{deployment_model_path}'")

# 2. Create a deployment configuration
print("\n2. Creating Deployment Configuration...")

deployment_config = {
    "model": {
        "path": deployment_model_path,
        "input_name": "X",
        "output_name": "Y",
        "input_shape": [None, 10],
        "output_shape": [None, 3],
        "dtype": "float32"
    },
    "runtime": {
        "execution_provider": "CPUExecutionProvider",
        "optimization_level": "ORT_ENABLE_ALL",
        "inter_op_num_threads": 4,
        "intra_op_num_threads": 2,
        "execution_mode": "ORT_PARALLEL"
    },
    "api": {
        "version": "1.0",
        "endpoint": "/predict",
        "methods": ["POST"],
        "input_format": "json",
        "output_format": "json"
    },
    "monitoring": {
        "enable_metrics": True,
        "metrics_interval": 60,
        "log_requests": True,
        "log_responses": False
    },
    "security": {
        "enable_auth": False,
        "api_keys": []
    }
}

# Save configuration
with open('deployment_config.json', 'w') as f:
    json.dump(deployment_config, f, indent=2)

print("Deployment configuration saved to 'deployment_config.json'")

# 3. Create a REST API for model serving
print("\n3. Creating REST API for Model Serving...")

app = Flask(__name__)

# Load model and configuration
with open('deployment_config.json', 'r') as f:
    config = json.load(f)

# Create ONNX Runtime session
sess_options = ort.SessionOptions()
sess_options.graph_optimization_level = getattr(ort.GraphOptimizationLevel,
                                               config['runtime']['optimization_level'])
sess_options.inter_op_num_threads = config['runtime']['inter_op_num_threads']
sess_options.intra_op_num_threads = config['runtime']['intra_op_num_threads']
sess_options.execution_mode = getattr(ort.ExecutionMode, config['runtime']['execution_mode'])

# Create session with specified execution provider
execution_provider = config['runtime']['execution_provider']
session = ort.InferenceSession(
    config['model']['path'],
    sess_options,
    providers=[execution_provider]
)

# Get input and output names
input_name = session.get_inputs()[0].name
output_name = session.get_outputs()[0].name

print(f"Model loaded with input: {input_name}, output: {output_name}")
print(f"Execution provider: {execution_provider}")

# API endpoint for predictions
@app.route(config['api']['endpoint'], methods=config['api']['methods'])
def predict():
    """API endpoint for model predictions"""
    start_time = time.time()

    try:
        # Get input data from request
        if request.content_type != 'application/json':
            return jsonify({
                "error": "Content-Type must be application/json",
                "status": "error"
            }), 415

        data = request.get_json()

        # Validate input
        if 'input' not in data:
            return jsonify({
                "error": "Missing 'input' field in request",
                "status": "error"
            }), 400

        input_data = np.array(data['input'], dtype=np.float32)

        # Validate input shape
        if len(input_data.shape) != 2 or input_data.shape[1] != 10:
            return jsonify({
                "error": f"Input must have shape [batch_size, 10], got {input_data.shape}",
                "status": "error"
            }), 400

        # Run inference
        outputs = session.run([output_name], {input_name: input_data})
        predictions = outputs[0].tolist()

        # Prepare response
        response = {
            "predictions": predictions,
            "model": config['model']['path'],
            "status": "success",
            "processing_time": time.time() - start_time
        }

        return jsonify(response)

    except Exception as e:
        return jsonify({
            "error": str(e),
            "status": "error",
            "processing_time": time.time() - start_time
        }), 500

# Health check endpoint
@app.route('/health', methods=['GET'])
def health_check():
    """Health check endpoint"""
    return jsonify({
        "status": "healthy",
        "model_loaded": True,
        "execution_provider": execution_provider,
        "timestamp": time.time()
    })

# Model metadata endpoint
@app.route('/metadata', methods=['GET'])
def model_metadata():
    """Model metadata endpoint"""
    metadata = {
        "model": config['model']['path'],
        "input_name": config['model']['input_name'],
        "output_name": config['model']['output_name'],
        "input_shape": config['model']['input_shape'],
        "output_shape": config['model']['output_shape'],
        "onnx_version": onnx.__version__,
        "onnxruntime_version": ort.__version__,
        "execution_provider": execution_provider,
        "metadata": {prop.key: prop.value for prop in model.metadata_props}
    }

    return jsonify(metadata)

print("REST API endpoints created:")
print(f"  Prediction endpoint: {config['api']['endpoint']}")
print(f"  Health check endpoint: /health")
print(f"  Metadata endpoint: /metadata")

# 4. Test the API locally
print("\n4. Testing the API Locally...")

# Create test data
test_input = np.random.randn(3, 10).astype(np.float32).tolist()

# Test prediction endpoint
print("Testing prediction endpoint...")
test_data = {"input": test_input}

# In a real scenario, we would use requests.post()
# For this example, we'll simulate the API call
with app.test_request_context(
    config['api']['endpoint'],
    method='POST',
    json=test_data,
    content_type='application/json'
):
    response = predict()
    print(f"Response status: {response.status_code}")
    print(f"Response data: {response.get_json()}")

# Test health endpoint
print("\nTesting health endpoint...")
with app.test_request_context('/health', method='GET'):
    response = health_check()
    print(f"Response status: {response.status_code}")
    print(f"Response data: {response.get_json()}")

# Test metadata endpoint
print("\nTesting metadata endpoint...")
with app.test_request_context('/metadata', method='GET'):
    response = model_metadata()
    print(f"Response status: {response.status_code}")
    print(f"Response data keys: {list(response.get_json().keys())}")

# 5. Create a client for the API
print("\n5. Creating API Client...")

class ONNXModelClient:
    """Client for ONNX model API"""

    def __init__(self, base_url):
        self.base_url = base_url

    def predict(self, input_data):
        """Make prediction request"""
        import requests

        url = f"{self.base_url}{config['api']['endpoint']}"
        headers = {'Content-Type': 'application/json'}

        data = {"input": input_data}

        try:
            response = requests.post(url, json=data, headers=headers)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            return {"error": str(e), "status": "error"}

    def health_check(self):
        """Check API health"""
        import requests

        url = f"{self.base_url}/health"

        try:
            response = requests.get(url)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            return {"error": str(e), "status": "error"}

    def get_metadata(self):
        """Get model metadata"""
        import requests

        url = f"{self.base_url}/metadata"

        try:
            response = requests.get(url)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            return {"error": str(e), "status": "error"}

# Example usage
print("Example client usage:")
client = ONNXModelClient("http://localhost:5000")

# Test client methods
print("Client created. In a real deployment, you would use:")
print("  client = ONNXModelClient('http://your-api-url:port')")
print("  predictions = client.predict(input_data)")
print("  health = client.health_check()")
print("  metadata = client.get_metadata()")

# 6. Deployment considerations
print("\n6. Deployment Considerations...")

deployment_considerations = [
    "1. **Containerization**: Package the model and API in a Docker container for easy deployment",
    "2. **Scaling**: Use container orchestration (Kubernetes) for horizontal scaling",
    "3. **Load Balancing**: Implement load balancing for high traffic scenarios",
    "4. **Monitoring**: Set up monitoring for performance, errors, and model drift",
    "5. **Logging**: Implement comprehensive logging for debugging and auditing",
    "6. **Security**: Secure the API with authentication and HTTPS",
    "7. **Model Versioning**: Implement model versioning for rollback and A/B testing",
    "8. **CI/CD Pipeline**: Set up continuous integration and deployment for model updates",
    "9. **Hardware Acceleration**: Use GPUs or specialized hardware for performance-critical applications",
    "10. **Fallback Mechanism**: Implement fallback to CPU if GPU is unavailable",
    "11. **Model Caching**: Cache frequent predictions to reduce computation",
    "12. **Input Validation**: Validate all inputs to prevent malicious or malformed data",
    "13. **Rate Limiting**: Implement rate limiting to prevent abuse",
    "14. **Documentation**: Provide comprehensive API documentation",
    "15. **Testing**: Implement thorough testing (unit, integration, load testing)"
]

print("Key deployment considerations:")
for consideration in deployment_considerations:
    print(f"  • {consideration}")

# 7. Create a Dockerfile for deployment
print("\n7. Creating Dockerfile for Deployment...")

dockerfile_content = """# ONNX Model Serving Dockerfile
FROM python:3.8-slim

# Set environment variables
ENV PYTHONDONTWRITEBYTECODE 1
ENV PYTHONUNBUFFERED 1

# Install system dependencies
RUN apt-get update && apt-get install -y --no-install-recommends \\
    build-essential \\
    && rm -rf /var/lib/apt/lists/*

# Install Python dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Copy application files
COPY deployment_model.onnx .
COPY deployment_config.json .
COPY app.py .

# Set working directory
WORKDIR /app

# Expose port
EXPOSE 5000

# Health check
HEALTHCHECK --interval=30s --timeout=3s \\
    CMD curl -f http://localhost:5000/health || exit 1

# Run the application
CMD ["gunicorn", "--bind", "0.0.0.0:5000", "--workers", "4", "app:app"]
"""

# Save Dockerfile
with open('Dockerfile', 'w') as f:
    f.write(dockerfile_content)

# Create requirements.txt
requirements_content = """flask==2.0.1
gunicorn==20.1.0
numpy==1.21.2
onnx==1.10.1
onnxruntime==1.9.0
"""

with open('requirements.txt', 'w') as f:
    f.write(requirements_content)

print("Dockerfile and requirements.txt created")
print("To build and run the container:")
print("  docker build -t onnx-model-server .")
print("  docker run -p 5000:5000 onnx-model-server")

# 8. Cloud deployment options
print("\n8. Cloud Deployment Options...")

cloud_options = [
    {
        "name": "AWS",
        "services": [
            "AWS SageMaker",
            "AWS Lambda",
            "AWS ECS/EKS",
            "AWS EC2"
        ],
        "features": [
            "Managed ONNX Runtime",
            "Auto-scaling",
            "GPU support",
            "Model monitoring"
        ]
    },
    {
        "name": "Google Cloud",
        "services": [
            "Google Vertex AI",
            "Google Cloud Run",
            "Google Kubernetes Engine",
            "Google Compute Engine"
        ],
        "features": [
            "ONNX model serving",
            "AutoML integration",
            "TPU support",
            "Model versioning"
        ]
    },
    {
        "name": "Azure",
        "services": [
            "Azure Machine Learning",
            "Azure Kubernetes Service",
            "Azure Functions",
            "Azure Container Instances"
        ],
        "features": [
            "Native ONNX support",
            "GPU acceleration",
            "Model management",
            "CI/CD integration"
        ]
    },
    {
        "name": "IBM Cloud",
        "services": [
            "IBM Watson Machine Learning",
            "IBM Cloud Kubernetes Service",
            "IBM Cloud Functions"
        ],
        "features": [
            "ONNX model deployment",
            "Auto-scaling",
            "Model monitoring",
            "Explainability"
        ]
    }
]

print("Cloud deployment options:")
for option in cloud_options:
    print(f"\n{option['name']}:")
    print(f"  Services: {', '.join(option['services'])}")
    print(f"  Features: {', '.join(option['features'])}")

# 9. Edge deployment considerations
print("\n9. Edge Deployment Considerations...")

edge_considerations = [
    "1. **Model Size**: Optimize model size for edge devices with limited storage",
    "2. **Memory Constraints**: Ensure model fits within device memory limitations",
    "3. **Compute Power**: Optimize for devices with limited CPU/GPU capabilities",
    "4. **Power Efficiency**: Minimize power consumption for battery-powered devices",
    "5. **Latency Requirements**: Meet real-time processing requirements",
    "6. **Connectivity**: Handle intermittent or limited network connectivity",
    "7. **Security**: Secure models and data on edge devices",
    "8. **Updates**: Implement efficient model update mechanisms",
    "9. **Hardware Acceleration**: Leverage specialized hardware (NPUs, TPUs) when available",
    "10. **Fallback Mechanisms**: Implement fallback to simpler models if performance is insufficient",
    "11. **Data Privacy**: Process sensitive data locally to maintain privacy",
    "12. **Environmental Conditions**: Handle varying temperature, humidity, and other conditions",
    "13. **Device Management**: Implement remote monitoring and management of edge devices",
    "14. **Offline Operation**: Support offline operation with local model storage",
    "15. **Edge-Cloud Synergy**: Implement hybrid edge-cloud architectures for optimal performance"
]

print("Edge deployment considerations:")
for consideration in edge_considerations:
    print(f"  • {consideration}")

# 10. Monitoring and maintenance
print("\n10. Monitoring and Maintenance...")

monitoring_components = [
    {
        "name": "Performance Monitoring",
        "metrics": [
            "Inference latency",
            "Throughput (requests/second)",
            "CPU/GPU utilization",
            "Memory usage",
            "Batch processing time"
        ],
        "tools": [
            "Prometheus",
            "Grafana",
            "Cloud monitoring services"
        ]
    },
    {
        "name": "Model Monitoring",
        "metrics": [
            "Prediction distribution",
            "Input data distribution",
            "Model drift detection",
            "Accuracy metrics",
            "Error rates"
        ],
        "tools": [
            "MLflow",
            "Evidently AI",
            "Arize",
            "WhyLabs"
        ]
    },
    {
        "name": "Operational Monitoring",
        "metrics": [
            "API uptime",
            "Error rates",
            "Request volume",
            "Response times",
            "System health"
        ],
        "tools": [
            "Datadog",
            "New Relic",
            "ELK Stack",
            "Sentry"
        ]
    },
    {
        "name": "Security Monitoring",
        "metrics": [
            "Authentication failures",
            "Unauthorized access attempts",
            "Data breaches",
            "API abuse detection",
            "Compliance violations"
        ],
        "tools": [
            "AWS GuardDuty",
            "Azure Security Center",
            "Google Cloud Security Command Center"
        ]
    }
]

print("Monitoring components:")
for component in monitoring_components:
    print(f"\n{component['name']}:")
    print(f"  Metrics: {', '.join(component['metrics'])}")
    print(f"  Tools: {', '.join(component['tools'])}")

# Maintenance tasks
maintenance_tasks = [
    "1. **Model Updates**: Regularly update models with new data and improved algorithms",
    "2. **Performance Tuning**: Continuously optimize model performance based on monitoring data",
    "3. **Security Patches**: Apply security updates to dependencies and infrastructure",
    "4. **Hardware Maintenance**: Maintain and upgrade hardware as needed",
    "5. **Data Pipeline Maintenance**: Ensure data pipelines feeding the model are functioning correctly",
    "6. **Dependency Updates**: Keep dependencies up-to-date with security fixes and new features",
    "7. **Documentation Updates**: Maintain up-to-date documentation for APIs and models",
    "8. **Disaster Recovery**: Implement and test disaster recovery procedures",
    "9. **Capacity Planning**: Monitor resource usage and plan for capacity increases",
    "10. **User Feedback**: Collect and incorporate user feedback to improve model performance",
    "11. **Compliance Audits**: Conduct regular audits to ensure compliance with regulations",
    "12. **Cost Optimization**: Monitor and optimize cloud costs and resource utilization",
    "13. **Model Retraining**: Schedule regular model retraining with fresh data",
    "14. **A/B Testing**: Conduct A/B tests for new model versions before full deployment",
    "15. **Incident Response**: Implement and maintain incident response procedures"
]

print("\nMaintenance tasks:")
for task in maintenance_tasks:
    print(f"  • {task}")

# Performance comparison example with ONNX
import numpy as np
import onnx
import onnxruntime as ort
import time
import matplotlib.pyplot as plt

print("\nPerformance Comparison Example...")

# 1. Create test models for comparison
print("1. Creating Test Models for Comparison...")

# Simple model (single layer)
X_simple = helper.make_tensor_value_info('X', TensorProto.FLOAT, [None, 10])
Y_simple = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [None, 3])

W_simple = np.random.randn(10, 3).astype(np.float32)
b_simple = np.random.randn(3).astype(np.float32)

W_simple_tensor = helper.make_tensor('W', TensorProto.FLOAT, W_simple.shape, W_simple.flatten().tolist())
b_simple_tensor = helper.make_tensor('b', TensorProto.FLOAT, b_simple.shape, b_simple.tolist())

node_simple = helper.make_node('Gemm', ['X', 'W', 'b'], ['Y'], alpha=1.0, beta=1.0)
graph_simple = helper.make_graph([node_simple], 'simple-model', [X_simple], [Y_simple], [W_simple_tensor, b_simple_tensor])
model_simple = helper.make_model(graph_simple, producer_name='onnx-simple')
onnx.save(model_simple, 'simple_model.onnx')

# Medium model (two layers)
X_medium = helper.make_tensor_value_info('X', TensorProto.FLOAT, [None, 10])
Y_medium = helper.make_tensor_value_info('Y', TensorProto.FLOAT, [None, 3])

W1_medium = np.random.randn(10, 20).astype(np.float32)
b1_medium = np.random.randn(20).astype(np.float32)
W2_medium = np.random.randn(20, 3).astype(np.float32)
b2_medium = np.random.randn(3).astype(np.float32)

W1_medium_tensor = helper.make_tensor('W1', TensorProto.FLOAT, W1_medium.shape, W1_medium.flatten().tolist())
b1_medium_tensor = helper.make_tensor('b1', TensorProto.FLOAT, b1_medium.shape, b1_medium.tolist())
W2_medium_tensor = helper.make_tensor('W2', TensorProto.FLOAT, W2_medium.shape, W2_medium.flatten().tolist())
b2_medium_tensor = helper.make_tensor('b2', TensorProto.FLOAT, b2_medium.shape, b2_medium.tolist())

node1_medium = helper.make_node('Gemm', ['X', 'W1', 'b1'], ['hidden'])
node2_medium = helper.make_node('Relu', ['hidden'], ['hidden_relu'])
node3_medium = helper.make_node('Gemm', ['hidden_relu', 'W2', 'b2'], ['Y'])

graph_medium = helper.make_graph(
    [node1_medium, node2_medium, node3_medium],
    'medium-model',
    [X_medium],
    [Y_medium],
    [W1_medium_tensor, b1_medium_tensor, W2_medium_tensor, b2_medium_tensor]
)
model_medium = helper.make_model(graph_medium, producer_name='onnx-medium')
onnx.save(model_medium, 'medium_model.onnx')

# Complex model (three layers - already created)
# We'll use the complex_model.onnx created earlier

print("Test models created:")
print("  • Simple model: 1 layer")
print("  • Medium model: 2 layers")
print("  • Complex model: 3 layers")

# 2. Benchmark different model complexities
print("\n2. Benchmarking Different Model Complexities...")

# Create test data
X_test = np.random.randn(1000, 10).astype(np.float32)

# Benchmark function
def benchmark_model(model_path, input_data, n_runs=100):
    """Benchmark ONNX model"""
    sess_options = ort.SessionOptions()
    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
    session = ort.InferenceSession(model_path, sess_options)

    # Warm-up
    for _ in range(10):
        session.run(['Y'], {'X': input_data})

    # Benchmark
    start_time = time.time()
    for _ in range(n_runs):
        session.run(['Y'], {'X': input_data})
    elapsed_time = time.time() - start_time

    return elapsed_time / n_runs

# Benchmark models
models = [
    ('Simple', 'simple_model.onnx'),
    ('Medium', 'medium_model.onnx'),
    ('Complex', 'complex_model.onnx')
]

complexity_times = []
complexity_throughputs = []

for name, model_path in models:
    print(f"\nBenchmarking {name} model...")

    avg_time = benchmark_model(model_path, X_test)
    throughput = len(X_test) / avg_time

    complexity_times.append(avg_time)
    complexity_throughputs.append(throughput)

    print(f"  Average time: {avg_time:.6f} seconds")
    print(f"  Throughput: {throughput:.2f} samples/second")

# Plot complexity comparison
plt.figure(figsize=(12, 5))

plt.subplot(1, 2, 1)
plt.bar([name for name, _ in models], complexity_times)
plt.title('Inference Time by Model Complexity')
plt.ylabel('Time (seconds)')

plt.subplot(1, 2, 2)
plt.bar([name for name, _ in models], complexity_throughputs)
plt.title('Throughput by Model Complexity')
plt.ylabel('Samples/second')

plt.tight_layout()
plt.show()

# 3. Compare ONNX with native frameworks
print("\n3. Comparing ONNX with Native Frameworks...")

framework_comparison = []

# Compare with PyTorch
try:
    import torch
    import torch.nn as nn

    print("PyTorch available, comparing with ONNX...")

    # Create PyTorch model equivalent to the medium ONNX model
    class PyTorchModel(nn.Module):
        def __init__(self):
            super(PyTorchModel, self).__init__()
            self.linear1 = nn.Linear(10, 20)
            self.linear2 = nn.Linear(20, 3)

        def forward(self, x):
            x = torch.relu(self.linear1(x))
            x = self.linear2(x)
            return x

    # Initialize model
    pytorch_model = PyTorchModel()
    pytorch_model.eval()

    # Set weights to match ONNX model
    with torch.no_grad():
        pytorch_model.linear1.weight.copy_(torch.from_numpy(W1_medium.T))
        pytorch_model.linear1.bias.copy_(torch.from_numpy(b1_medium))
        pytorch_model.linear2.weight.copy_(torch.from_numpy(W2_medium.T))
        pytorch_model.linear2.bias.copy_(torch.from_numpy(b2_medium))

    # Benchmark PyTorch model
    X_torch = torch.from_numpy(X_test)

    # Warm-up
    for _ in range(10):
        with torch.no_grad():
            pytorch_model(X_torch)

    # Benchmark
    n_runs = 100
    start_time = time.time()
    for _ in range(n_runs):
        with torch.no_grad():
            pytorch_model(X_torch)
    pytorch_time = (time.time() - start_time) / n_runs
    pytorch_throughput = len(X_test) / pytorch_time

    print(f"PyTorch average time: {pytorch_time:.6f} seconds")
    print(f"PyTorch throughput: {pytorch_throughput:.2f} samples/second")

    # Compare with ONNX
    onnx_time = complexity_times[1]  # Medium model
    onnx_throughput = complexity_throughputs[1]

    print(f"ONNX average time: {onnx_time:.6f} seconds")
    print(f"ONNX throughput: {onnx_throughput:.2f} samples/second")

    framework_comparison.append({
        'framework': 'PyTorch',
        'time': pytorch_time,
        'throughput': pytorch_throughput,
        'speedup': onnx_time / pytorch_time if pytorch_time > 0 else float('inf')
    })

except ImportError:
    print("PyTorch not available, skipping PyTorch comparison")

# Compare with TensorFlow
try:
    import tensorflow as tf
    from tensorflow.keras import layers

    print("TensorFlow available, comparing with ONNX...")

    # Create TensorFlow model equivalent to the medium ONNX model
    tf_model = tf.keras.Sequential([
        layers.Dense(20, activation='relu', input_shape=(10,)),
        layers.Dense(3)
    ])

    # Set weights to match ONNX model
    tf_model.layers[0].set_weights([W1_medium.T, b1_medium])
    tf_model.layers[1].set_weights([W2_medium.T, b2_medium])

    # Benchmark TensorFlow model
    X_tf = tf.convert_to_tensor(X_test)

    # Warm-up
    for _ in range(10):
        tf_model(X_tf)

    # Benchmark
    n_runs = 100
    start_time = time.time()
    for _ in range(n_runs):
        tf_model(X_tf)
    tf_time = (time.time() - start_time) / n_runs
    tf_throughput = len(X_test) / tf_time

    print(f"TensorFlow average time: {tf_time:.6f} seconds")
    print(f"TensorFlow throughput: {tf_throughput:.2f} samples/second")

    # Compare with ONNX
    onnx_time = complexity_times[1]  # Medium model
    onnx_throughput = complexity_throughputs[1]

    print(f"ONNX average time: {onnx_time:.6f} seconds")
    print(f"ONNX throughput: {onnx_throughput:.2f} samples/second")

    framework_comparison.append({
        'framework': 'TensorFlow',
        'time': tf_time,
        'throughput': tf_throughput,
        'speedup': onnx_time / tf_time if tf_time > 0 else float('inf')
    })

except ImportError:
    print("TensorFlow not available, skipping TensorFlow comparison")

# Plot framework comparison
if framework_comparison:
    plt.figure(figsize=(12, 5))

    frameworks = [fc['framework'] for fc in framework_comparison]
    times = [fc['time'] for fc in framework_comparison]
    throughputs = [fc['throughput'] for fc in framework_comparison]

    plt.subplot(1, 2, 1)
    plt.bar(frameworks, times)
    plt.title('Inference Time by Framework')
    plt.ylabel('Time (seconds)')

    plt.subplot(1, 2, 2)
    plt.bar(frameworks, throughputs)
    plt.title('Throughput by Framework')
    plt.ylabel('Samples/second')

    plt.tight_layout()
    plt.show()

    # Print comparison table
    print("\nFramework Comparison:")
    print(f"{'Framework':<15} {'Time (s)':<12} {'Throughput':<15} {'Speedup':<10}")
    print("-" * 55)
    for fc in framework_comparison:
        print(f"{fc['framework']:<15} {fc['time']:.6f}    {fc['throughput']:.2f}       {fc['speedup']:.2f}x")

    # Add ONNX to the comparison
    onnx_fc = {
        'framework': 'ONNX Runtime',
        'time': complexity_times[1],
        'throughput': complexity_throughputs[1],
        'speedup': 1.0
    }
    print(f"{onnx_fc['framework']:<15} {onnx_fc['time']:.6f}    {onnx_fc['throughput']:.2f}       {onnx_fc['speedup']:.2f}x")

# 4. Memory usage comparison
print("\n4. Memory Usage Comparison...")

# Function to estimate memory usage
def estimate_memory_usage(model_path):
    """Estimate memory usage of ONNX model"""
    # Load model
    model = onnx.load(model_path)

    # Calculate parameter memory
    param_memory = 0
    for initializer in model.graph.initializer:
        # Each float32 parameter uses 4 bytes
        param_memory += np.prod(initializer.dims) * 4

    # Calculate activation memory (approximate)
    # This is a rough estimate based on input/output sizes
    input_size = np.prod(model.graph.input[0].type.tensor_type.shape.dim[1:].dim_value) * 4
    output_size = np.prod(model.graph.output[0].type.tensor_type.shape.dim[1:].dim_value) * 4
    activation_memory = input_size + output_size

    # Total memory estimate
    total_memory = param_memory + activation_memory

    return {
        'parameter_memory': param_memory / (1024 * 1024),  # MB
        'activation_memory': activation_memory / (1024 * 1024),  # MB
        'total_memory': total_memory / (1024 * 1024)  # MB
    }

# Compare memory usage
print("Memory usage comparison (MB):")
print(f"{'Model':<10} {'Parameters':<12} {'Activations':<15} {'Total':<10}")
print("-" * 50)

for name, model_path in models:
    memory = estimate_memory_usage(model_path)
    print(f"{name:<10} {memory['parameter_memory']:.2f}        {memory['activation_memory']:.2f}         {memory['total_memory']:.2f}")

# 5. Scalability testing
print("\n5. Scalability Testing...")

# Test with different input sizes
input_sizes = [100, 1000, 10000, 100000]
scalability_results = {name: [] for name, _ in models}

for size in input_sizes:
    print(f"\nTesting with {size} samples...")

    X_large = np.random.randn(size, 10).astype(np.float32)

    for name, model_path in models:
        avg_time = benchmark_model(model_path, X_large, n_runs=10)
        throughput = size / avg_time
        scalability_results[name].append({
            'size': size,
            'time': avg_time,
            'throughput': throughput
        })
        print(f"  {name} model: {avg_time:.6f}s, {throughput:.2f} samples/s")

# Plot scalability results
plt.figure(figsize=(12, 10))

# Time vs input size
plt.subplot(2, 1, 1)
for name, results in scalability_results.items():
    sizes = [r['size'] for r in results]
    times = [r['time'] for r in results]
    plt.plot(sizes, times, marker='o', label=name)
plt.title('Inference Time vs Input Size')
plt.xlabel('Input Size (samples)')
plt.ylabel('Time (seconds)')
plt.xscale('log')
plt.yscale('log')
plt.legend()
plt.grid(True)

# Throughput vs input size
plt.subplot(2, 1, 2)
for name, results in scalability_results.items():
    sizes = [r['size'] for r in results]
    throughputs = [r['throughput'] for r in results]
    plt.plot(sizes, throughputs, marker='o', label=name)
plt.title('Throughput vs Input Size')
plt.xlabel('Input Size (samples)')
plt.ylabel('Throughput (samples/second)')
plt.xscale('log')
plt.legend()
plt.grid(True)

plt.tight_layout()
plt.show()

# 6. Real-world scenario simulation
print("\n6. Real-World Scenario Simulation...")

# Simulate a production scenario with varying load
def simulate_production_load(model_path, load_pattern, warmup=100):
    """Simulate production load on a model"""
    # Create session
    sess_options = ort.SessionOptions()
    sess_options.graph_optimization_level = ort.GraphOptimizationLevel.ORT_ENABLE_ALL
    session = ort.InferenceSession(model_path, sess_options)

    # Warm-up
    X_warmup = np.random.randn(100, 10).astype(np.float32)
    for _ in range(warmup):
        session.run(['Y'], {'X': X_warmup})

    # Simulate load
    results = []
    for i, batch_size in enumerate(load_pattern):
        X_batch = np.random.randn(batch_size, 10).astype(np.float32)

        start_time = time.time()
        session.run(['Y'], {'X': X_batch})
        elapsed_time = time.time() - start_time

        throughput = batch_size / elapsed_time
        results.append({
            'batch_size': batch_size,
            'time': elapsed_time,
            'throughput': throughput,
            'request_id': i
        })

    return results

# Define load patterns
load_patterns = {
    'Steady': [100] * 50,
    'Spiky': [10, 10, 10, 1000, 10, 10, 10, 1000, 10, 10],
    'Increasing': [10, 20, 50, 100, 200, 500, 1000, 2000],
    'Decreasing': [2000, 1000, 500, 200, 100, 50, 20, 10]
}

# Simulate for each model
simulation_results = {}

for name, model_path in models:
    print(f"\nSimulating production load for {name} model...")
    simulation_results[name] = {}

    for pattern_name, pattern in load_patterns.items():
        print(f"  Simulating {pattern_name} load pattern...")
        results = simulate_production_load(model_path, pattern)
        simulation_results[name][pattern_name] = results

        # Calculate statistics
        times = [r['time'] for r in results]
        throughputs = [r['throughput'] for r in results]

        avg_time = np.mean(times)
        avg_throughput = np.mean(throughputs)
        max_time = np.max(times)
        min_throughput = np.min(throughputs)

        print(f"    Avg time: {avg_time:.6f}s, Avg throughput: {avg_throughput:.2f} samples/s")
        print(f"    Max time: {max_time:.6f}s, Min throughput: {min_throughput:.2f} samples/s")

# Plot simulation results
for pattern_name in load_patterns:
    plt.figure(figsize=(15, 10))

    # Plot for each model
    for i, (name, results_dict) in enumerate(simulation_results.items()):
        results = results_dict[pattern_name]
        batch_sizes = [r['batch_size'] for r in results]
        times = [r['time'] for r in results]
        throughputs = [r['throughput'] for r in results]

        plt.subplot(2, 2, i+1)
        plt.plot(batch_sizes, times, marker='o')
        plt.title(f'{name} Model - {pattern_name} Load')
        plt.xlabel('Batch Size')
        plt.ylabel('Time (seconds)')
        plt.grid(True)

    plt.tight_layout()
    plt.show()