1. API Overview
2. Installation and Import
3. Package Structure
4. Tensor API
5. Tensor Creation
6. Mathematical Operations
7. Automatic Differentiation
8. Neural Network API
9. Optimization API
10. Data Processing API
11. Training API
12. Backend and Device API
13. Mixed Precision API
14. Serialization and ONNX
15. Quantization API
16. Profiling and Visualization
17. Configuration and Logging
18. Exceptions
19. API Inspection and Compatibility
20. Developer References
21. Next Steps

EveryO exposes a Python interface for neural computing and machine learning experimentation.

Its public exports cover tensor operations, gradient tracking, neural network modules, optimizers, data utilities, training workflows, serialization, and optional integrations.

import everyo as eo

The eo alias is used throughout this reference.

git clone https://github.com/krishanth7/EveryO.git
cd EveryO

python -m pip install -e .

The repository declares these optional dependency groups:

Example:

python -m pip install -e ".[dev]"

import everyo as eo

print(eo.__version__)

EveryO organizes functionality across several Python modules.

everyo
 |
 +-- core
 |    +-- tensor
 |    +-- operations
 |    +-- autograd
 |    +-- device
 |    +-- dtype
 |    +-- convolution
 |
 +-- nn
 |
 +-- optim
 |
 +-- data
 |
 +-- training
 |
 +-- backends
 |
 +-- cuda
 |
 +-- precision
 |
 +-- serialization
 |
 +-- quantization
 |
 +-- profiler
 |
 +-- visualization
 |
 +-- config

This is a simplified functional map, not an exhaustive directory listing.

The public API is defined by the exports in:

everyo/__init__.py

Developers can inspect available symbols using:

import everyo as eo

for name in eo.__all__:
    print(name)

The Tensor class represents multidimensional numerical data with optional gradient tracking.

The source defines the following constructor:

Tensor(
    data,
    *,
    dtype=None,
    device="cpu",
    requires_grad=False,
    name=None
)

import everyo as eo

x = eo.tensor([
    [1.0, 2.0],
    [3.0, 4.0]
])

print(x.shape)

Expected output:

(2, 2)

The Tensor implementation exposes data and shape information.

import everyo as eo

x = eo.tensor([1.0, 2.0, 3.0])

print(x.shape)
print(x.data)

import everyo as eo

x = eo.tensor([[1.0, 2.0]])
y = eo.tensor([[3.0], [4.0]])

result = eo.matmul(x, y)

print(result.item())

Expected output:

11.0

Source: Tensor Implementation

EveryO publicly exports the following tensor creation functions.

import everyo as eo

x = eo.zeros(3, 4)

print(x.shape)

import everyo as eo

identity = eo.eye(3)

print(identity.data)

EveryO exposes mathematical functions through its top-level namespace.

Core Operations

EveryO exports gradient-control utilities.

import everyo as eo

x = eo.tensor(
    [1.0, 2.0, 3.0],
    requires_grad=True
)

import everyo as eo

with eo.no_grad():
    x = eo.tensor([1.0, 2.0, 3.0])
    y = eo.multiply(x, x)

The autograd system is concerned with:

• Computational dependencies.
• Backward propagation.
• Gradient accumulation.
• Differentiable tensor operations.
• Gradient-tracking state.

Related Documentation: Automatic Differentiation

EveryO exports neural network components from everyo.nn.

Linear(
    in_features,
    out_features,
    *,
    bias=True,
    initializer="he_uniform",
    seed=None
)

import everyo as eo

layer = eo.Linear(4, 2, seed=0)

x = eo.zeros(3, 4)

output = layer(x)

print(output.shape)

Expected output:

(3, 2)

Source: Neural Network Layers

EveryO exports the following optimizer classes.

from everyo import SGD, Adam

A typical optimization process includes:

1. Model parameter initialization.
2. Forward computation.
3. Loss calculation.
4. Gradient calculation.
5. Parameter updates.

Inspect exact optimizer signatures using:

import inspect
import everyo as eo

print(inspect.signature(eo.SGD))
print(inspect.signature(eo.Adam))

Do not assume that optimizer parameter names or defaults match those of another machine learning framework.

Related Documentation: Optimization

EveryO exports dataset and preprocessing utilities.

import inspect
import everyo as eo

print(inspect.signature(eo.DataLoader))

EveryO exports model training utilities and callbacks.

import inspect
import everyo as eo

print(inspect.signature(eo.Trainer))

Developers should confirm:

• Callback lifecycle methods.
• Training state passed to callbacks.
• Checkpoint storage behavior.
• Scheduler update frequency.
• Exception handling.

EveryO publicly exposes:

import everyo as eo

print(eo.backends)
print(eo.cuda)

Device behavior depends on:

• Available hardware.
• Installed dependencies.
• Backend implementation.
• Supported operations.
• Runtime configuration.

EveryO exports mixed-precision utilities.

Mixed precision can reduce memory usage and improve performance on suitable hardware.

However, numerical behavior depends on:

• Data type.
• Supported operations.
• Hardware.
• Loss scaling.
• Backend implementation.

import inspect
import everyo as eo

print(inspect.signature(eo.autocast))
print(inspect.signature(eo.GradScaler))

EveryO exports model serialization and interoperability utilities.

python -m pip install -e ".[onnx]"

Not all models or operations are necessarily supported by the ONNX export paths.

Confirm supported:

• Operators.
• Input shapes.
• Model architectures.
• ONNX versions.
• Runtime dependencies.

Treat untrusted serialized artifacts as potentially unsafe.

Do not assume that a file is safe merely because it has a recognized extension.

EveryO publicly exports quantization-related utilities.

Quantization may help reduce:

• Model storage requirements.
• Numerical representation size.
• Memory bandwidth requirements.

Performance benefits depend on the implementation and execution hardware.

Inspect signatures before use:

import inspect
import everyo as eo

print(inspect.signature(eo.quantize))
print(inspect.signature(eo.quantize_dynamic))

import everyo as eo

plotter = eo.plot_loss

print(plotter)

Check function signatures before passing training data or plotting options.

import inspect
import everyo as eo

print(inspect.signature(eo.Config))
print(inspect.signature(eo.TrainingConfig))

• Validate required values.
• Document defaults.
• Avoid storing secrets in source control.
• Record reproducibility-related settings.
• Keep environment-specific configuration separate.

EveryO defines custom exception classes.

import everyo as eo

try:
    layer = eo.Linear(0, 4)
except eo.EveryOShapeError as error:
    print("Invalid layer shape:", error)

The Linear implementation rejects non-positive feature counts.

• Catch specific exception classes.
• Preserve useful diagnostic information.
• Avoid silently ignoring failed operations.
• Log unexpected errors.
• Validate inputs before expensive computations.

Because EveryO is in alpha development, API introspection is an important part of integration.

import everyo as eo

for name in sorted(eo.__all__):
    print(name)

import inspect
import everyo as eo

for name in ["tensor", "matmul", "Linear", "SGD", "Adam"]:
    obj = getattr(eo, name)

    try:
        signature = inspect.signature(obj)
    except (TypeError, ValueError):
        signature = "Signature unavailable"

    print(f"{name}: {signature}")

import everyo as eo

help(eo.Tensor)
help(eo.Linear)
help(eo.Adam)

Until a formal stability guarantee is published:

• Avoid assuming long-term signature stability.
• Pin a tested release or commit.
• Run integration tests after upgrades.
• Review the changelog.
• Report regressions through GitHub Issues.

Each detailed API entry should include:

Continue with the following EveryO Wiki pages.

Wiki links become active when their corresponding pages are created.