### Build and install from source

Source: https://github.com/asiryan/caffe2onnx/blob/main/README.md

Clone the repository and perform a local installation using setup.py.

```bash
git clone https://github.com/asiryan/caffe2onnx
python setup.py install
```

--------------------------------

### Install caffe2onnx from GitHub

Source: https://github.com/asiryan/caffe2onnx/blob/main/README.md

Install the latest development version directly from the repository.

```bash
pip install git+https://github.com/asiryan/caffe2onnx
```

--------------------------------

### Install caffe2onnx via pip

Source: https://github.com/asiryan/caffe2onnx/blob/main/README.md

Standard installation method using the Python package index.

```bash
pip install caffe2onnx
```

--------------------------------

### Complete Conversion Pipeline Example

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

An end-to-end example demonstrating the programmatic conversion of a Caffe model to ONNX, including loading, converting, freezing, and saving the model.

```APIDOC
## Complete Conversion Pipeline

### Description
Full end-to-end example demonstrating programmatic conversion of a Caffe model to ONNX with all available options.

### Method
Python Script

### Endpoint
N/A (Illustrative script)

### Parameters
#### Script Configuration Variables
- `prototxt_path` (string) - Path to the Caffe prototxt file.
- `caffemodel_path` (string) - Path to the Caffe caffemodel file.
- `onnx_output_path` (string) - Path for the output ONNX file.

### Request Example
```python
from caffe2onnx.src.load_save_model import loadcaffemodel, saveonnxmodel
from caffe2onnx.src.caffe2onnx import Caffe2Onnx
from caffe2onnx.src.utils import freeze
import onnx
import onnxruntime as ort
import numpy as np

# Configuration
prototxt_path = 'models/vgg16.prototxt'
caffemodel_path = 'models/vgg16.caffemodel'
onnx_output_path = 'models/vgg16.onnx'

# Step 1: Load Caffe model
print("Loading Caffe model...")
graph, params = loadcaffemodel(prototxt_path, caffemodel_path)

# Step 2: Convert to ONNX
print("Converting to ONNX...")
converter = Caffe2Onnx(graph, params, onnx_output_path)
onnx_model = converter.createOnnxModel()

# Step 3: Freeze for inference (optional)
freeze(onnx_model)

# Step 4: Save ONNX model
saveonnxmodel(onnx_model, onnx_output_path)

# Step 5: Verify and run inference
print("Verifying ONNX model...")
onnx.checker.check_model(onnx_model)

# Example of running inference (requires onnxruntime and sample input)
# sess = ort.InferenceSession(onnx_output_path)
# input_name = sess.get_inputs()[0].name
# dummy_input = np.random.rand(1, 3, 224, 224).astype(np.float32) # Example input shape for VGG16
# outputs = sess.run(None, {input_name: dummy_input})
# print("Inference successful.")
```

### Response
- **Console Output**: Prints status messages during loading, conversion, freezing, and verification.
- **File Output**: An ONNX model file saved at `onnx_output_path`.
```

--------------------------------

### Complete Caffe to ONNX Conversion Pipeline

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

An end-to-end example demonstrating the programmatic conversion of a Caffe model to ONNX, including loading, conversion, freezing, saving, and verification.

```python
from caffe2onnx.src.load_save_model import loadcaffemodel, saveonnxmodel
from caffe2onnx.src.caffe2onnx import Caffe2Onnx
from caffe2onnx.src.utils import freeze
import onnx
import onnxruntime as ort
import numpy as np

# Configuration
prototxt_path = 'models/vgg16.prototxt'
caffemodel_path = 'models/vgg16.caffemodel'

onnx_output_path = 'models/vgg16.onnx'

# Step 1: Load Caffe model
print("Loading Caffe model...")
graph, params = loadcaffemodel(prototxt_path, caffemodel_path)

# Step 2: Convert to ONNX
print("Converting to ONNX...")
converter = Caffe2Onnx(graph, params, onnx_output_path)
onnx_model = converter.createOnnxModel()

# Step 3: Freeze for inference (optional)
freeze(onnx_model)

# Step 4: Save ONNX model
saveonnxmodel(onnx_model, onnx_output_path)

# Step 5: Verify and run inference
print("Verifying ONNX model...")
onnx.checker.check_model(onnx_model)
```

--------------------------------

### Run Inference with ONNX Runtime

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Demonstrates how to load an ONNX model, prepare dummy input, and execute inference using the ONNX Runtime session.

```python
# Run inference with ONNX Runtime
session = ort.InferenceSession(onnx_output_path)
input_name = session.get_inputs()[0].name
input_shape = session.get_inputs()[0].shape

# Create dummy input (batch_size, channels, height, width)
dummy_input = np.random.randn(1, 3, 224, 224).astype(np.float32)
outputs = session.run(None, {input_name: dummy_input})
print(f"Inference output shape: {outputs[0].shape}")
```

--------------------------------

### Convert Caffe model to ONNX

Source: https://github.com/asiryan/caffe2onnx/blob/main/README.md

Execute the conversion script with the required prototxt path and optional model, output, and frozen graph arguments.

```bash
python -m caffe2onnx.convert
    --prototxt          caffe prototxt file path
    [--caffemodel       caffe caffemodel file path]
    [--onnx             output onnx file path]
    [--frozen           frozen graph or not]
```

--------------------------------

### Command Line Interface for Conversion

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Convert Caffe models to ONNX format using the command-line tool. This tool parses Caffe prototxt files and caffemodel weights to generate an ONNX model.

```APIDOC
## Command Line Interface for Conversion

### Description
Convert Caffe models to ONNX format using the command-line tool. The tool requires a prototxt file and optionally accepts caffemodel weights, output path, and frozen graph options.

### Method
Command Line Tool

### Endpoint
`python -m caffe2onnx.convert`

### Parameters
#### Command Line Arguments
- `--prototxt` (string) - Required - Path to the Caffe prototxt file.
- `--caffemodel` (string) - Optional - Path to the Caffe caffemodel file. If not provided, it's inferred from the prototxt filename.
- `--onnx` (string) - Optional - Path for the output ONNX file. Defaults to a name derived from the prototxt file.
- `--frozen` (boolean) - Optional - If set to `True`, the converted ONNX model will be frozen, meaning non-constant initializers are removed.

### Request Example
```bash
# Basic conversion with prototxt only (caffemodel inferred from prototxt name)
python -m caffe2onnx.convert --prototxt model.prototxt

# Full conversion with all options
python -m caffe2onnx.convert \
    --prototxt /path/to/model.prototxt \
    --caffemodel /path/to/model.caffemodel \
    --onnx /path/to/output.onnx \
    --frozen True

# Example: Convert ResNet model
python -m caffe2onnx.convert \
    --prototxt resnet50.prototxt \
    --caffemodel resnet50.caffemodel \
    --onnx resnet50.onnx
```

### Response
No direct response body, but the command generates an ONNX file at the specified or inferred output path.
```

--------------------------------

### Load Caffe Model Files

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Load Caffe model files (prototxt and caffemodel) into memory. This function returns parsed network definition and model parameters as protobuf objects.

```python
from caffe2onnx.src.load_save_model import loadcaffemodel

# Load Caffe model files
net, model = loadcaffemodel(
    net_path='model.prototxt',
    model_path='model.caffemodel'
)

# net contains the network architecture (layers, connections)
# model contains the trained weights and biases
print(f"Loaded {len(net.layer)} layers")
```

--------------------------------

### Check Supported Caffe Operators

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Provides a list of supported operators for Caffe2ONNX v2.* and a helper function to verify if a specific operator is supported.

```python
# Supported operators in caffe2onnx v2.* (onnx 1.6.0):
supported_operators = [
    'Add',              # Element-wise addition
    'Axpy',             # ax + y operation
    'BatchNorm',        # Batch normalization
    'Clip',             # ReLU6 and value clipping
    'Concat',           # Tensor concatenation
    'Conv',             # 2D convolution
    'ConvTranspose',    # Transposed convolution (deconvolution)
    'Crop',             # Tensor cropping via Slice
    'DetectionOutput',  # SSD detection output
    'Dropout',          # Dropout layer
    'Eltwise',          # Element-wise operations
    'Flatten',          # Flatten to 2D
    'Gemm',             # General matrix multiply (InnerProduct)
    'InstanceNorm',     # Instance normalization
    'Interp',           # Interpolation/upsampling
    'Log',              # Logarithm
    'LpNormalization',  # Lp normalization
    'LRN',              # Local response normalization
    'Min',              # Element-wise minimum
    'Mul',              # Element-wise multiplication
    'Pooling',          # Max/Average pooling
    'Power',            # Power operation
    'PRelu',            # Parametric ReLU
    'PriorBox',         # SSD prior box generation
    'ReLU',             # ReLU activation
    'Reshape',          # Tensor reshape
    'Resize',           # Resize/upsample
    'Shuffle',          # Channel shuffle
    'Sigmoid',          # Sigmoid activation
    'Slice',            # Tensor slicing
    'Softmax',          # Softmax activation
    'Tanh',             # Tanh activation
    'Transpose',        # Tensor transpose (Permute)
    'UnPooling',        # Max unpooling
    'Upsample',         # Upsampling via resize
]

# Check if an operator is supported
def is_operator_supported(op_name):
    return op_name in supported_operators
```

--------------------------------

### Caffe2Onnx Class for Conversion

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Instantiate the Caffe2Onnx class to convert Caffe network definitions and parameters into an ONNX model. This class handles layer-by-layer conversion and maintains graph connectivity.

```python
from caffe2onnx.src.load_save_model import loadcaffemodel, saveonnxmodel
from caffe2onnx.src.caffe2onnx import Caffe2Onnx

# Load Caffe model
graph, params = loadcaffemodel('model.prototxt', 'model.caffemodel')

# Create converter and build ONNX model
converter = Caffe2Onnx(
    net=graph,           # Caffe network definition
    model=params,        # Caffe model parameters
    onnxname='model.onnx'  # Output model name
)

# Generate ONNX model
onnx_model = converter.createOnnxModel()

# Save the converted model
saveonnxmodel(onnx_model, 'model.onnx')
```

--------------------------------

### loadcaffemodel Function

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Loads Caffe model files (prototxt and caffemodel) into memory. This function parses the network definition and model parameters.

```APIDOC
## loadcaffemodel Function

### Description
Load Caffe model files (prototxt and caffemodel) into memory. Returns parsed network definition and model parameters as protobuf objects.

### Method
Python Function

### Endpoint
`caffe2onnx.src.load_save_model.loadcaffemodel`

### Parameters
#### Function Parameters
- `net_path` (string) - Required - Path to the Caffe prototxt file.
- `model_path` (string) - Required - Path to the Caffe caffemodel file.

### Request Example
```python
from caffe2onnx.src.load_save_model import loadcaffemodel

# Load Caffe model files
net, model = loadcaffemodel(
    net_path='model.prototxt',
    model_path='model.caffemodel'
)

# net contains the network architecture (layers, connections)
# model contains the trained weights and biases
print(f"Loaded {len(net.layer)} layers")
```

### Response
- `net` (protobuf object) - The parsed network definition.
- `model` (protobuf object) - The parsed model parameters (weights and biases).
```

--------------------------------

### Freeze ONNX Model for Inference

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Use the freeze utility to remove non-constant initializers from the ONNX model graph inputs. This creates a frozen graph optimized for inference by treating all weights as constants.

```python
from caffe2onnx.src.utils import freeze
from caffe2onnx.src.load_save_model import loadcaffemodel, saveonnxmodel
from caffe2onnx.src.caffe2onnx import Caffe2Onnx

# Load and convert model
graph, params = loadcaffemodel('model.prototxt', 'model.caffemodel')
converter = Caffe2Onnx(graph, params, 'model.onnx')
onnx_model = converter.createOnnxModel()

# Freeze the model for inference
freeze(onnx_model)
# Output: "removing not constant initializers from model"
# Output: "frozen graph has been created"

# Save the frozen model
saveonnxmodel(onnx_model, 'model_frozen.onnx')
```

--------------------------------

### Save ONNX Model to Disk

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Save a generated ONNX model to disk using the saveonnxmodel function. This function also performs model validation and handles save errors.

```python
from caffe2onnx.src.load_save_model import saveonnxmodel
import onnx

# Assuming onnx_model is already created via Caffe2Onnx
saveonnxmodel(onnx_model, '/output/path/model.onnx')
# Output: "onnx model has been successfully saved to /output/path/model.onnx"

# Load and verify the saved model
loaded_model = onnx.load('/output/path/model.onnx')
onnx.checker.check_model(loaded_model)
```

--------------------------------

### Caffe2Onnx Class

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

The main class for converting Caffe network definitions and parameters into an ONNX model. It handles layer-by-layer conversion and maintains graph connectivity.

```APIDOC
## Caffe2Onnx Class

### Description
The main conversion class that transforms Caffe network definitions and parameters into an ONNX model. Handles layer-by-layer conversion and maintains graph connectivity.

### Method
Python Class

### Endpoint
`caffe2onnx.src.caffe2onnx.Caffe2Onnx`

### Parameters
#### Constructor Parameters
- `net` (protobuf object) - Required - The Caffe network definition loaded via `loadcaffemodel`.
- `model` (protobuf object) - Required - The Caffe model parameters loaded via `loadcaffemodel`.
- `onnxname` (string) - Required - The desired name for the output ONNX model file.

### Request Example
```python
from caffe2onnx.src.load_save_model import loadcaffemodel, saveonnxmodel
from caffe2onnx.src.caffe2onnx import Caffe2Onnx

# Load Caffe model
graph, params = loadcaffemodel('model.prototxt', 'model.caffemodel')

# Create converter and build ONNX model
converter = Caffe2Onnx(
    net=graph,           # Caffe network definition
    model=params,        # Caffe model parameters
    onnxname='model.onnx'  # Output model name
)

# Generate ONNX model
onnx_model = converter.createOnnxModel()

# Save the converted model
saveonnxmodel(onnx_model, 'model.onnx')
```

### Methods
#### `createOnnxModel()`
- **Description**: Generates the ONNX model from the provided Caffe network and parameters.
- **Returns**: An ONNX model object.
```

--------------------------------

### freeze Function

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Removes non-constant initializers from the ONNX model graph inputs, creating a frozen graph suitable for inference. This optimizes the model by treating all weights as constants.

```APIDOC
## freeze Function

### Description
Remove non-constant initializers from the ONNX model graph inputs, creating a frozen graph suitable for inference. This optimizes the model by treating all weights as constants.

### Method
Python Function

### Endpoint
`caffe2onnx.src.utils.freeze`

### Parameters
#### Function Parameters
- `onnx_model` (object) - Required - The ONNX model object to be frozen.

### Request Example
```python
from caffe2onnx.src.utils import freeze
from caffe2onnx.src.load_save_model import loadcaffemodel, saveonnxmodel
from caffe2onnx.src.caffe2onnx import Caffe2Onnx

# Load and convert model
graph, params = loadcaffemodel('model.prototxt', 'model.caffemodel')
converter = Caffe2Onnx(graph, params, 'model.onnx')
onnx_model = converter.createOnnxModel()

# Freeze the model for inference
freeze(onnx_model)
# Output: "removing not constant initializers from model"
# Output: "frozen graph has been created"

# Save the frozen model
saveonnxmodel(onnx_model, 'model_frozen.onnx')
```

### Response
- **Output Messages**: Prints messages indicating the freezing process, e.g., "removing not constant initializers from model" and "frozen graph has been created". The `onnx_model` object is modified in-place.
```

--------------------------------

### saveonnxmodel Function

Source: https://context7.com/asiryan/caffe2onnx/llms.txt

Saves a generated ONNX model to disk. This function also performs model validation and handles save errors.

```APIDOC
## saveonnxmodel Function

### Description
Save a generated ONNX model to disk. Performs model validation and handles save errors gracefully.

### Method
Python Function

### Endpoint
`caffe2onnx.src.load_save_model.saveonnxmodel`

### Parameters
#### Function Parameters
- `onnx_model` (object) - Required - The ONNX model object to save.
- `output_path` (string) - Required - The file path where the ONNX model will be saved.

### Request Example
```python
from caffe2onnx.src.load_save_model import saveonnxmodel
import onnx

# Assuming onnx_model is already created via Caffe2Onnx
saveonnxmodel(onnx_model, '/output/path/model.onnx')
# Output: "onnx model has been successfully saved to /output/path/model.onnx"

# Load and verify the saved model
loaded_model = onnx.load('/output/path/model.onnx')
onnx.checker.check_model(loaded_model)
```

### Response
- **Success Message**: A string indicating the successful save, e.g., "onnx model has been successfully saved to /output/path/model.onnx".
- **Validation**: The function internally checks the model's validity using `onnx.checker.check_model`.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.