Open Tasks

Here, we explain all tasks which are currently open for contributions from the community!

This section of the docs will be updated frequently, whereby new tasks will be added and completed tasks will be removed. The tasks outlined here are generally broad high-level tasks, each of which is made up of many individual sub-tasks, distributed across task-specific ToDo list issues.

The tasks currently open are:

  1. Function Formatting

  2. Frontend APIs

We try to explain these tasks as clearly as possible, but in cases where things are not clear, then please feel free to engage with the open tasks discussion, or reach out on discord in the open tasks channel!

Please always use the latest commit on GitHub when working on any of these tasks, DO NOT develop your code using the latest PyPI release of ivy-core.

Function Formatting

Currently, we have many ToDo list issues open for a general function formatting task, which is explained below.

Each function in each submodule should be updated to follow the implementation instructions given in the Deep Dive section. The updates should be applied for the:

  1. ivy API

  2. all backend APIs

  3. container static methods

  4. array instance methods

  5. container instance methods

  6. array operators

  7. array reverse operators

  8. container operators

  9. container reverse operators

The Deep Dive is an essential resource for learning how each of these functions/methods should be implemented. Before starting any contribution task, you should go through the Deep Dive, and familiarize yourself with the content.

At the time of writing, many of the functions are not implemented as they should be. You will need to make changes to the current implementations, but you do not need to address all sections of the Deep Dive in detail. Specifically, you do not need to address the following:

  1. implement the hypothesis testing for the function

  2. get the tests passing for your function, if they are failing before you start

However, everything else covered in the Deep Dive must be addressed. Some common important tasks are:

  1. remove all lambda and direct bindings for the backend functions (in ivy.functional.backends), with each function instead defined using def.

  2. implement the following if they don’t exist but should do: ivy.Array instance method, ivy.Container static method, ivy.Container instance method, ivy.Array special method, ivy.Array reverse special method, ivy.Container special method, ivy.Container reverse special method.

  3. Make sure that the aforementioned methods are added into the correct category-specific parent class, such as ivy.ArrayWithElementwise, ivy.ContainerWithManipulation etc.

  4. correct all of the Function Arguments and the type hints for every function and its relevant methods, including those you did not implement yourself.

  5. add the correct Docstrings to every function and its relevant methods, including those you did not implement yourself.

  6. add thorough Docstring Examples for every function and its relevant methods and ensure they pass the docstring tests.

Frontend APIs

For this task, the goal will be to implement functions for each of the frontend functional APIs (see Ivy as a Transpiler), with frontend APIs implemented for: JAX, MXNet, NumPy, TensorFlow and PyTorch.

Currently, we have many ToDo list issues open for this task, which is explained below.

The general workflow for this task is:

  1. implement the function by following the Ivy Frontends guide

  2. write tests for your function by following the Ivy Frontend Tests guide

  3. verify that the tests for your function are passing

There are a few points to take note of when working on your chosen frontend function:

  1. you should only implement one frontend function.

  2. the frontend function is framework-specific, thus it should be implemented in its respective frontend framework only.

  3. each frontend function should be tested on all backends to ensure that conversions are working correctly.

  4. type hints, docstrings and examples are not required for frontend functions.

In the case where your chosen function exists in all frameworks by default, but is not implemented in Ivy’s functional API, please convert your existing GitHub issue to request for the function to be added to Ivy. Meanwhile, you can select another frontend function to work on from the ToDo list! If you’re stuck on a function which requires complex compositions, you’re allowed to reselect a function too!

Round Up

This should have hopefully given you a good understanding of the basics for contributing.

If you’re ever unsure of how best to proceed, please feel free to engage with the open tasks discussion, or reach out on discord in the open tasks channel!