SolutionsBusiness Operations

Business Operations

View as Markdown

Business Operations with Kumo

Data science teams are responsible for a wide variety of predictive tasks: supply chain optimization, demand forecasting, pricing, revenue forecasting, customer claim classification, inventory optimization, and predictive maintenance. With many competing priorities, data scientists often struggle to build and maintain models across all these areas.

Kumo is a machine learning platform that eliminates the manual work of traditional predictive modeling. Instead of hand-crafting features and model architectures, data scientists describe what they want to predict, and Kumo handles the rest. This lets a small team cover many more predictive use cases.

The core of Kumo is its Predictive Query Language (PQL): a concise, SQL-like syntax for defining what you want to predict. Kumo translates PQL statements into Graph Neural Networks (GNNs), a type of deep learning model that captures relationships between entities in your data (for example, between customers, products, and transactions). Kumo also works with Large Language Models (LLMs), enabling teams to work with unstructured text data and build explainable, chat-powered interfaces for predictions.

Kumo can work directly on the relational data already in your data warehouse. Its Data Warehouse Native deployment mode processes data within your Snowflake or Databricks account, so your data never leaves your environment. This minimizes security reviews and simplifies compliance.

Solutions

PQL lets data scientists describe a predictive task in a few lines of code, specifying the entity to predict for, the target outcome, any filters, and the optimization goal. Kumo handles all model training automatically.

Below are a few of the solutions that Kumo supports.

Kumo is a good fit for…

  • Data science and machine learning teams looking to build automated business operation pipelines based on predicted outcomes
  • Business analysts and operation managers that want to obtain the best-performing predictive outcomes flexibly without the help of data scientists or ML engineers
  • Predictive tasks that need to consider a lot of dependencies across various entities and use various datasets
  • Businesses with unique requirements that need to reflect own business process and constraints beyond industry standard
  • Engineering teams looking to improve their existing automated systems by powering better models and more data
  • Organizations looking to invest in a general machine learning platform to uplevel a wide variety of solutions beyond predictive analytics, including recommendation and fraud detection

Stand-out Features

  • PQL provides the SQL-like language for predictive tasks and eliminates the need for feature engineering and model development pipeline.
  • Kumo connector enables you to connect multiple datasets you own. You retain full control over your data.
  • Kumo graph can represent the dependencies among various entities of your business, directly reflected from your relational data.
  • Multiple Predictive Queries can share the underlying Kumo graph and data.
  • Combining GNNs and LLMs trained on your data with LLMs on public data gives strong performance by drawing on both your domain knowledge and general world knowledge.
  • Prediction filters enable predictive tasks to incorporate business logic flexibly. For example, Kumo can predict demand only for new items released in the last month.
  • Kumo explainability provides insights about predictions that can be understood and leveraged by humans.
  • GNN model planner enables data scientists to tune the model architecture for the dataset, including the training split, neighborhood sampling strategy, and model hyperparameters.
  • Support for visual signal (image-based) and LLM-powered text understanding.
  • The Python SDK allows data scientists and ML engineers to develop, test, and deploy models directly from notebooks or as part of an automated workflow.

Data Requirements

Kumo does not require data to be transformed to fit a prescriptive schema.

Instead, Kumo produces predictions directly from the raw data that already exists in the data warehouse. The Kumo graph builder makes it straightforward to stitch together data from many different sources.

For the best predictive results, Kumo works well with data such as:

  • Customer profile information
  • Operation outcome (such as on-time vs. late) history
  • Operation status change history (such as in-transit, submitted)
  • Backbone network data (for example, supply-chain route)
  • Promotion and discount history
  • External data such as weather forecasts that can impact prediction performance

By using all of your data, Kumo can achieve better prediction quality compared to solutions that can only use a subset.

Data Connectivity

Kumo reads and writes data directly to your data lakehouse, supporting cloud-first data science workflows. Supported lakehouses include Snowflake, Databricks, AWS S3, and GCP BigQuery. For example, users have found success using Kumo as part of a DBT-based development environment, using Airflow for orchestration, and Streamlit for consumption.

Data Warehouse Native

Additionally, Kumo provides Data Warehouse Native deployment options, which keep your data secure by performing data processing within your Snowflake or Databricks account. This makes Kumo suitable for use in highly regulated environments, including banking, healthcare, and government.

Scale

Kumo uses a distributed GNN training system that can handle multi-terabyte datasets with tens of billions of rows. This system currently supports users making daily recommendations for more than 100M active users or more than 10M inventory items. Kumo is also ideal for small datasets containing thousands of users and tens of items, as GNNs are effective at discovering complex patterns in sparse data.

Operational Serving

While Kumo supports a variety of serving methods for predictions, batch export to the data warehouse is the most common for predictive operations:

  • Batch Export: Export bulk predictions through the UI or API to the warehouse. This produces all the prediction scores to be easily fed to other automated pipelines or data analytics tools.

Model Architecture

Kumo’s predictions are powered by a GNN architecture. Data scientists benefit from state-of-the-art model designs without needing to implement them manually. Kumo’s AutoML system selects the best combination of the following architectures for your data:

  • GraphSAGE does both transductive and inductive representation learning to deliver great predictions for entities with various dependencies and histories
  • ID-GNN is a training process that enables the model to learn patterns such as repeat purchase or brand affinity
  • PNA introduces a variety of aggregation operators which are explored by Kumo AutoML
  • GCN describes mean-pooling aggregation, which captures similarity between entities with similar historical patterns
  • GIN captures frequency signal to learn more complex behavior like frequent operation events vs. rare events
  • NBF networks reduce the computational cost of models by providing an efficient way to capture paths between nodes
  • GraphMixer uses temporal representation learning to interpret sequences of operation events
  • RDL describes temporal sampling, which learns from past sequences of events to predict the future

Data Encoding

Before training, Kumo encodes your raw data into numerical representations that the GNN can learn from. It supports a wide range of data types:

  • PyTorch Frame finds the best encoding for a variety of tabular data types
  • LLM foundation models can be used for understanding rich text data
  • Absolute and relative time encodings learn historical and seasonal patterns
  • Image Pixel Data can be used through image encoders such as CLIP

Model Planner

The Kumo model planner empowers data scientists to quickly iterate and apply their domain knowledge to the model.

Specifically, the Kumo model planner gives control over:

  • Training table splits
  • Neighborhood sampling
  • Column encoding
  • Training process
  • GNN architecture
  • Optimization goals

Predictive Query Language

PQL is a declarative syntax for defining machine learning problems. It is flexible, supporting inline filters and boolean expressions and aggregation functions.

Data scientists can quickly experiment with many different predictive formulations of a machine learning problem in very few lines of code.

For example, the following PQL statement predicts the number of winter clearance items sold in the US in the next two weeks.

PREDICT COUNT(
  purchases.item_id               
  	WHERE purchases.markdown > 0.2 AND purchases.country = 'US', 0, 14)
FOR EACH item.item_id WHERE item.season = 'winter'

Evaluation and Explainability

As part of the training process, Kumo automatically computes data visualizations and metrics to help understand the model’s strengths and weaknesses.

  • Learning Curves and Distribution: Detects under and overfitting by monitoring convergence rates. Tracks distribution of training data over time for balance.
  • Backtesting on Holdout: All models are back-tested on a configurable holdout dataset. The holdout dataset may be downloaded for further analysis.
  • Standard Evaluation Metrics and Charts: Including ROC and PRC curve, cumulative gain chart, AUPRC, AUROC, predicted vs. actual scatter plot and histogram, MAE, MSE, RMSE, SMAPE, average precision, per-category recall, F1, and MAP.
  • Baseline Comparison: Models are benchmarked against an automatically generated analytic baseline.
  • Column Explainability: A visualization highlighting which columns have the greatest predictive power helps identify potential data leakage.
  • Row Level Explainability: Users can understand the reason for individual predictions by seeing which rows contributed most to the result.

MLOps

To support ongoing validation of model correctness, Kumo provides the following MLOps features:

  • Data Source Snapshotting: During each job, data source statistics are snapshotted including size, time range, and import time, to enable faster root cause analysis.
  • Drift Detection: Distributions of features and predictions are monitored for drift. This enables early detection of issues, preventing bad predictions from being published to production.
  • Champion / Challenger: A champion / challenger approach can be adopted to validate key metrics of a newly trained model when orchestrating automatic job retraining through the REST API.