Welcome to the advanced tutorial! Here, we will explore more advanced features ECiDA provides through extending the basic pipeline from the quickstart guide. We will add configurability to modules and performance metrics to modules that you can use to configure and better monitor your pipeline. Furthermore, we will make sure of pipeline versioning to create variants of pipelines without overwriting the existing pipeline.

Extending pipelines with configurations and metrics link

In the quickstart guide, we made a doubler module that multiplies input values by two. This tutorial adds flexibility to this module. Instead of always doubling the input, we will introduce a configurable multiplier a such that the module can be reused with different settings.

In the quickstart, we also made a number-printer module that simply prints any input that it receives. This module will be extended as well. We will demonstrate how to collect metrics, and monitor these in the app, through summary statistics such as standard deviation and a live updating chart.

In short, the following sections will solve the following issue:

Calculate y = ax (where a is determined when creating the pipeline) and get statistics of the numbers in this pipeline.

Step 1. Enhancing modules with configurations and metrics link

Let’s start with adding flexibility to the doubler module. Instead of simply doubling the input, we want it to modify the value through multiplying by any integer weight a.

For clarity’s sake, let’s duplicate the doubler.py file and name it to multiplier.py.

Adding configurations is as simple as adding inputs and outputs. We define the allowed configuration in the create_module function by adding M.add_config:

  
def create_module() -> EcidaModule:
    # Change the second parameter to something of your liking
    M = EcidaModule("multiplier", "v1")
    M.add_description("Executes the function y = ax.")

    M.add_input("in", "int")

    M.add_output("out", "int")

    # Define config for a
    M.add_config("a", "int")

    return M
  

Now, let’s use this parameter in our module logic. We retrieve it via M.get_config and can then use it like any other variable in our code:

  
def main(M: EcidaModule):
    logger.info(f"START MODULE {M.name}:{M.version}")

    # Get value for a
    a = int(M.get_config("a"))

    while True:
        sample = int(M.pull("in"))

        logger.info(f"Got number: {sample}")

        # Execute y = ax
        result = sample * a

        M.push("out", result)
  

Next, we want to know which numbers are generated. ECiDA allows the configuration of metrics that keep track of data in your pipelines, in a more advanced way than simply looking at the logs. Metrics show the evolution of your data in a chart and allow calculation of summary metrics such as the mean or standard deviation.

For this example, let’s add this metric to number-printer, since its primary function is to show the numbers for us.

We’re now modifying an existing module, so it’s appropriate to increment its version to keep the old module still around. Copy the source code of number-printer.py in a different file, say number-printer-v2.py. Then, in the first line of create_module, change the version parameter to v2:

  
def create_module() -> EcidaModule:
    # Change the second parameter to something of your liking
    M = EcidaModule("number-printer", "v2")
    M.add_description("Simple number printer")

    M.add_input("number", "int")

    return M    
  

To add metrics, we only need to change our main function. by adding a call to M.log_metric:

  
def main(M: EcidaModule):
    logger.info(f"START MODULE {M.name}:{M.version}")

    while True:
        number = int(M.pull("number"))

        logger.info(f"{number}")

        # Keep track of numbers flowing in
        M.log_metric("number", number)
        
  

That’s it! Let’s save the new modules by committing the changes and pushing to the remote:

  git add .
git commit -m "Add multiplier and update number printer with metrics"
git push
  

Step 2: Using the new modules in a new version of a pipeline link

We have updated our modules, and now we’re all set to update our pipeline. ECiDA provides a versioning system that allows you to create a new version based on an existing pipeline.

2.1 Creating a new version of a pipeline in the ECiDA App link

On the landing page, click the “Edit” button of our quickstart pipeline.

The old pipeline is now loaded in. We can prepare the new version by modifying the “Version tag” field in the Inspect panel. Let’s make this “v2”.

With the new version set, the save button changes its text to “Save as new version”. The old pipeline stays intact.

2.2 Adding and configuring the new modules link

Let’s now add our updated modules to the field. Remove doubler-v1 from the pipeline by pressing the red button inside the module node, or by clicking the module and pressing [DEL] on your keyboard. Do the same for number-printer-v1, since we are updating this as well. Then let’s add multiplier-v1 and number-printer-v2 and link them together with the generator:

We see for multiplier-v1 that the bottom section is now filled with a text field. Here, we can configure our config weight a. Let’s give it the value 4.

That is all we need for our updated pipeline. It is now ready to save, so let’s click “Save as new version” and head back to the landing page once it is finished.

Step 3. Deploying the pipeline and experimenting live link

Back on the landing page, we see a couple of changes in the pipelines table. Looking at “ECiDA Quickstart”, the table row now shows that there are two versions available, and that only v1 from the quickstart guide is deployed.

Once we expand the pipeline row by clicking row, we see our new v2 pop up. Once a pipeline has multiple versions, to access the view, manage and edit buttons, we need to expand the combined row first to inspect the individual versions.

The next step is to execute the pipeline by deploying it. However this time, instead of deploying to “development”, deploy the pipeline to the yellow “experiment” environment with a flask icon. These “whatif” environments allow you to modify pipelines while it is running, allowing you to dynamically experiment with your data science ideas.

Once the pipeline has been deployed to “experiment”, let’s head over to the viewer by clicking the “experiment” badge in the row for v2.

Inspecting the logs will now show that, indeed, the generated numbers are multiplied by 4. The config works! Furthermore, ce have also configured metrics for the number printer. If we click the Metrics tab in the Inspect panel, we can see how the metric evolves over time. We can also see some summary metrics below: as of the time of the screenshot, the largest number the printer has received is 40.

We can also see an extra “apply” button show up in the configurable multiplier-v1 module. This is a special feature available in whatif environments. Since we are in the “experiment” environment, we are able to modify the weight parameter live! Let’s change the weight from 4 to 10 and click the “apply” button. The pipeline will be updated, similar to saving pipelines, but only the modified module will be restarted. Once applying the new config has finished, and you are still at the metrics panel, you can see that the numbers now reach higher than before!

That’s it! What’s next? link

That’s all for the advanced tutorial! You now have the tools to make your pipelines more dynamic, insightful, and version-controlled. For more specific use cases, feel free to take a look at the how-to-guides for a complete overview of the specific features in a more general setting, such as updating existing pipelines and sending big datasets to modules.

Need help along the way? You can access this documentation anytime through the in-app Help button. For direct support, check out our Slack channel.

We hope this advanced tutorial gives you more inspiration to streamline your ML pipelines!

Exercise: Creating multiple links and multiple module instances link

We have extended the functionality of the number printer to show the numbers it receives over time. It is now connected to the multiplier output. However, since it can retrieve any number, it can also be connected to the number generator! Module inputs can receive any number of outputs of other modules, so we can directly connect our raw number generator results to number-printer-v2.

Or, if we want to keep the data separate, we can add a separate instance of number-printer-v2 in the editor. Multiple instances of the same module (including the same version) can be added to a pipeline, and each module can be renamed to an alias of your preference, such as raw-number-inspection for the printer connected to the number generator. Through this, we can make better use of the Metrics panel as well, since instead of one graph, we’ll have two: one for each metric, of which there are now one per printer: