Glossary#

All of these new words can get confusing! We’ve created a glossary to help nail down some Ivy terms that you might find tricky.

Automatic Code Conversions#

Allows code to be converted from one framework to another whilst retaining its functional assets.

Compositional Functions#

Compositional functions are functions that are implemented as a composition of other Ivy functions,

Convenience Functions#

Convenience functions can be used to organize and improve the code for other functions.

Framework#

Frameworks are interfaces that allow scientists and developers to build and deploy machine learning models faster and easier. E.g. Tensorflow and PyTorch.

Framework Handler#
Backend Handler#

Used to control which framework Ivy is converting code to.

Graph Compiler#

Graph Compilers map the high-level computational graph coming from frameworks to operations that are executable on a specific device.

Ivy Array#

The ivy.Array is a simple wrapper class, which wraps around the ivy.NativeArray.

Ivy Backends#

Ivy Backends are supported frameworks that Ivy can convert code to. The default is NumPy.

Ivy Compiler#

A wrapper function around native compiler functions, which uses lower level compilers such as XLA to compile to lower level languages such as C++, CUDA, TorchScript, etc.

Ivy Container#

An Ivy class which inherits from dict allows for storing nested data.

Ivy Frontends#

Ivy Frontends are supported frameworks that Ivy can convert code from.

Ivy Functional API#

Is used for defining complex models, the Ivy functional API does not implement its own backend but wraps around other frameworks functional APIs and brings them into alignment.

Ivy Tracer#

Ivy’s Tracer creates a graph as a composition of functions in the functional API in Python.

Ivy Transpiler#

The transpiler allows framework to framework code conversions for supported frameworks.

Mixed Functions#

Mixed functions are functions that have some backend-specific implementations but not for all backends.

Native Array#

The ivy.NativeArray is simply a placeholder class for a backend-specific array class, such as np.ndarray, tf.Tensor or torch.Tensor.

Nestable Functions#

Nestable functions are functions that can accept ivy.Container instances in place of any of the arguments.

Pipeline#

A pipeline is a means of automating the machine learning workflow by enabling data to be transformed and correlated into a model that can then be analyzed to achieve outputs.

Primary Functions#

Primary functions are the lowest level building blocks in Ivy and are generally implemented as light wrapping around an existing function in the backend framework, which serves a near-identical purpose.

Standalone Functions#

Standalone functions are functions that do not reference any other primary, compositional, or mixed functions whatsoever. These are mainly convenience functions.

Submodule Helper Functions#

These are standalone/convenience functions that are specific to a submodule.