Convert Machine Learning Code Between Frameworks

Ivy enables you to convert ML models, tools and libraries between frameworks using ivy.transpile

Installation

The easiest way to install Ivy is using pip:

bash
 pip install ivy

From Source

You can also install Ivy from source if you want to take advantage of the latest changes:

bash
 git clone https://github.com/ivy-llc/ivy.git
 cd ivy
 pip install --user -e .

Supported Frameworks

These are the frameworks that ivy.transpile currently supports conversions from and to. | Framework | Source | Target | |------------|:------:|:------:| | PyTorch | ✅ | 🚧 | | TensorFlow | 🚧 | ✅ | | JAX | 🚧 | ✅ | | NumPy | 🚧 | ✅ |

Using ivy

Here's some examples, to help you get started using Ivy! The examples page also features a wide range of demos and tutorials showcasing some more use cases for Ivy.

Transpiling any code from one framework to another

python
    import ivy
    import torch
    import tensorflow as tf
 
    def torch_fn(x):
        a = torch.mul(x, x)
        b = torch.mean(x)
        return x * a + b
 
    tffn = ivy.transpile(torchfn, source="torch", target="tensorflow")
 
    tfx = tf.convertto_tensor([1., 2., 3.])
    ret = tffn(tfx)

Tracing a computational graph of any code

python
    import ivy
    import torch
 
    def torch_fn(x):
        a = torch.mul(x, x)
        b = torch.mean(x)
        return x * a + b
 
    torch_x = torch.tensor([1., 2., 3.])
    graph = ivy.tracegraph(jaxfn, to="torch", args=(torch_x,))
    ret = graph(torch_x)

How does ivy work?

Ivy\'s transpiler allows you to use code from any other framework in your own code. Feel free to head over to the docs for the full API reference, but the functions you\'d most likely want to use are:

python
 Converts framework-specific code to a target framework of choice. See usage in the documentation
 ivy.transpile()
 
 Traces an efficient fully-functional graph from a function, removing all wrapping and redundant code. See usage in the documentation
 ivy.trace_graph()

`ivy.transpile` will eagerly transpile if a class or function is provided

python
 import ivy
 import torch
 import tensorflow as tf
 
 def torch_fn(x):
     x = torch.abs(x)
     return torch.sum(x)
 
 x1 = torch.tensor([1., 2.])
 x1 = tf.converttotensor([1., 2.])
 
 Transpilation happens eagerly
 tffn = ivy.transpile(testfn, source="torch", target="tensorflow")
 
 tf_fn is now tensorflow code and runs efficiently
 ret = tf_fn(x1)

`ivy.transpile` will lazily transpile if a module (library) is provided

python
 import ivy
 import kornia
 import tensorflow as tf
 
 x2 = tf.random.normal((5, 3, 4, 4))
 
 Module is provided -> transpilation happens lazily
 tf_kornia = ivy.transpile(kornia, source="torch", target="tensorflow")
 
 The transpilation is initialized here, and this function is converted to tensorflow
 ret = tfkornia.color.rgbto_grayscale(x2)
 
 Transpilation has already occurred, the tensorflow function runs efficiently
 ret = tfkornia.color.rgbto_grayscale(x2)

Contributing

We believe that everyone can contribute and make a difference. Whether it\'s writing code, fixing bugs, or simply sharing feedback, your contributions are definitely welcome and appreciated" Check out all of our Open Tasks, and find out more info in our Contributing Guide in the docs.

Citation

@article{lenton2021ivy, title={Ivy: Templated deep learning for inter-framework portability}, author={Lenton, Daniel and Pardo, Fabio and Falck, Fabian and James, Stephen and Clark, Ronald}, journal={arXiv preprint arXiv:2102.02886}, year={2021} }

🔗 More in this category