For machine learning teams, experiment tracking is a core part of the development process. Whether you're building a classic random forest or pushing the boundaries with a custom graph neural network (GNN), the ability to track your experiments can mean the difference between moving swiftly toward your goals and navigating blindly through a sea of data.

Imagine this: you’ve just trained a model that shows promise, but without proper tracking, you might find yourself lost in a maze of hyperparameters, training metrics, and versioning chaos. This is where the power of experiment tracking comes into play. It’s not just about logging results; it’s about creating a clear narrative of your machine learning journey.

At v4c, we support teams working across a wide range of use cases, many of which involve frequent iterations and custom modeling approaches. Tracking helps these teams stay organized, compare results easily, and make decisions based on data, not guesswork.

While many platforms offer built-in tracking for standard models, Dataiku truly shines with unparalleled flexibility. With MLflow seamlessly integrated into the platform, you can effortlessly log, compare, and deploy even the most intricate models, whether crafted from scratch in PyTorch, TensorFlow, or any other Python library.

In this post, we'll walk through how easy it is to bring robust MLOps to non-standard ML pipelines using Dataiku. We'll show how to hook in MLflow logging, where to find your results in the UI, and how to go from experiment to deployment — all within the same ecosystem.

Why Track Experiments?

Before diving into the how, let's talk about the why.

Tracking experiments aren't just about hygiene, it's about velocity. A good experiment tracking setup helps you:

• Avoid retraining the same model over and over
• See how data or parameter changes affect performance
• Reproduce top-performing models any time
• Share insights across team members seamlessly

In short, tracking is what makes your messy, creative, sometimes chaotic ML process repeatable and reliable. And the more custom your work is, the more critical it becomes.

At v4c, we’ve found this approach especially effective when helping clients manage large volumes of custom experimentation. The ability to trace experiments from code to deployment keeps both our data science teams and stakeholders aligned.

Integrating MLflow in Dataiku

What makes Dataiku shine is that you don't need to give up flexibility for control. You can write completely custom model code and still get full experiment tracking — all using Dataiku's native MLflow integration.

1. Set Up MLflow Tracking

Start by creating a managed folder to store your experiments. In a Python recipe or Jupyter notebook inside Dataiku:

dsfolder = project.get_managed_folder("FOLDER_ID")

mlflow_ext = project.get_mlflow_extension()

with project.setup_mlflow(dsfolder) as mlflow:

experiment_id = mlflow.create_experiment("MyExperimentName")

This connects your code to Dataiku's experiment tracking backend — no external setup required.

2. Log Parameters, Metrics, and Models

Once the experiment is set up, logging is simple. Inside an MLflow run block, you can track anything you care about:

with mlflow.start_run():

    # Log parameters

    mlflow.log_param("learning_rate", 0.001)

    mlflow.log_param("gnn_layers", 3)

    # Train your model (custom GNN example)

    model = MyCustomGNN(layers=3)

    train_loss = train_model(model, train_data)

    # Log metrics

    mlflow.log_metric("train_loss", train_loss)

    mlflow.log_metric("val_accuracy", validate_model(model, val_data))

    # Save the model

    mlflow.pytorch.log_model(model, "fraud_detection_gnn")

Even if your model is custom, like a GNN for detecting fraudulent transactions between cards and merchants, you can still log it and track it like any other model.

Dataiku Flow Snapshot

Let's take a look at the actual flow we've implemented in our Dataiku project:

In the flow above, you can see how we've structured our ML pipeline:

1. Data Preparation Stage - Where we handle preprocessing, feature engineering, and dataset partitioning
2. Model Training Zone - This is where our Python recipe with MLflow tracking lives
3. Evaluation Pipeline - Connected components that assess model performance
4. Deployment Path - The route from a successful experiment to a production model

The visual nature of Dataiku flows makes it easy to understand the entire ML lifecycle at a glance. Each node represents a specific step in the process, with our custom model training step highlighted in the center.

This visual representation also helps new team members quickly understand how experiments fit into the broader data pipeline, making knowledge transfer more efficient.

Exploring Model Runs in Dataiku

After logging a few runs, switch to the Experiments tab in Dataiku.

‍

Here you'll find:

• Parameters (like learning rate or number of layers)
• Metrics (like training loss or F1 score)
• Tags and comments
• Serialized model artifacts

You can compare runs, sort by performance, filter by date or tag, and even relaunch experiments from the UI. It's experiment tracking that works with you, not against you.

This centralized view is a game-changer for teams like ours at v4c, where multiple practitioners work on parallel experiments. It simplifies collaboration, ensures reproducibility, and streamlines the decision-making process when promoting models to production.

Training to Deployment

Once identified as the best-performing run in the Experiments tab, deploying it is as simple as clicking a button.

• Just select the run you want, and you'll see a "Deploy this model" option in the right-hand pane.

Dataiku automatically handles packaging and versioning — even for custom models like GNNs built in PyTorch — as long as the code environment includes the right dependencies.

One Tracking Setup, Many Use Cases

If it runs in a Dataiku code recipe, it can be tracked, no matter how unconventional your approach.

Examples:

• LSTMs (time series forecasting) 
• Siamese networks (similarity learning) 
• Transformers (NLP) 
• Image classification pipelines 
• Reinforcement learning agents 

How Can v4c Help?

At v4c, we help teams build and manage custom machine learning workflows in Dataiku. From integrating models with MLflow to setting up experiment tracking and governance, we ensure your process is organized, scalable, and ready for production. Whether you're just starting out or expanding an established practice, we provide the technical support to move faster and with confidence.

Final Thoughts: Empower Your Machine Learning Journey with Dataiku

When it comes to experiment tracking, the ideal solution should cater to every model, not just the standard ones that come pre-packaged. That’s where Dataiku truly excels—enabling you to track even the most highly customized and experimental workflows with ease.

With the powerful combination of Dataiku and MLflow, you can unlock a world of possibilities:

• Run Your Own Training Loops: Take full control of your training process, allowing for tailored experimentation that meets your unique needs.
• Log Every Parameter, Metric, and Model: Capture every detail of your experiments, ensuring that you have a comprehensive record to refer back to.
• Visually Explore and Compare Experiments: Gain insights at a glance with intuitive visualizations that make it easy to analyze and compare different iterations of your models.
• Deploy the Best Version Directly from the UI: Streamline your workflow by deploying your top-performing models with just a few clicks, all from a user-friendly interface.

This setup empowers your team to focus on what truly matters: building better models and driving innovation, rather than getting bogged down in the chaos of experiment management.

So, the next time you embark on a new, niche, or unconventional project, remember this: Dataiku has your back. Embrace the flexibility and power of experiment tracking, and watch your machine learning initiatives soar to new heights!