Food delivery

This example using Genius to predict delivery acceptance behavior among food delivery workers. The Bayesian network will allow us to understand the complex interrelationships between various factors affecting a delivery worker's decision to accept or decline delivery offers. This example showcases the capabilities of Genius (both the model editor and SDK) in the following areas:

Continual learning
Learning in the presence of latent variables

Delivery acceptance decisions are influenced by many different variables. We will utilize the following variables in our model:

Variables

Building the model

This section will show how to build the model in the Python SDK and the model editor.

Although it is possible to build the model in the model editor using the data-to-model wizard, we will instead build the model by hand in this tutorial. First, you must build the model in the editor by adding variable and factor nodes/edges to the editing canvas. Here is the resulting model:

Next, click on each variable and manually add the categories according to the table at the beginning of this tutorial. If you examine the factor probabilities you will see that they have been set automatically to discrete uniform.

The first step is to import the Genius model from the Python SDK:

from genius_client_sdk.model import GeniusModel

Next, we build the model by adding the variables and factors. For factor probabilities, we will initialize all values with a discrete uniform distribution.

model = GeniusModel()

model.add_variable(
    name="time_of_day", 
    values=["early_morning", "morning", "midday", "afternoon", "evening", "night"])

model.add_variable(
    name="maintenance",
    values=["not_needed", "needed"]
)

model.add_variable(
    name="availability",
    values=["unavailable", "available"]
)

model.add_variable(
    name="courier_experience",
    values=["novice", "experienced"]
)

model.add_variable(
    name="trip_distance",
    values=["short", "medium", "long"]
)

model.add_variable(
    name="courier_customer_distance",
    values=["close", "far"]
)

model.add_variable(
    name="trip_efficiency",
    values=["low", "medium", "high"]
)

model.add_variable(
    name="delivery_acceptance",
    values=["rejected", "accepted"]
)

# Priors
time_of_day_probs = np.array([0.166, 0.166, 0.167, 0.167, 0.167, 0.167])
maintenance_probs = np.array([0.5, 0.5])
courier_experience_probs = np.array([0.5, 0.5])
trip_distance_probs = np.array([0.33, 0.33, 0.34])
courier_customer_distance_probs = np.array([0.5, 0.5])

# Conditional distributions
availability_probs = np.array(
    [[[0.5, 0.5, 0.5, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5, 0.5, 0.5]],
     [[0.5, 0.5, 0.5, 0.5, 0.5, 0.5], [0.5, 0.5, 0.5, 0.5, 0.5, 0.5]]]
)

trip_efficiency_probs = np.array([[0.33, 0.33, 0.33, 0.33, 0.33, 0.33],
                                  [0.33, 0.33, 0.33, 0.33, 0.33, 0.33],
                                  [0.34, 0.34, 0.34, 0.34, 0.34, 0.34]])
trip_efficiency_probs = np.reshape(trip_efficiency_probs, newshape=(3, 3, 2))

delivery_acceptance_probs = np.array([[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5],
                                      [0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5]])

delivery_acceptance_probs = np.reshape(delivery_acceptance_probs, newshape=(2, 2, 2, 3))

model.add_factor(values=time_of_day_probs, target="time_of_day")
model.add_factor(values=maintenance_probs, target="maintenance")
model.add_factor(values=courier_experience_probs, target="courier_experience")
model.add_factor(values=trip_distance_probs, target="trip_distance")
model.add_factor(values=courier_customer_distance_probs, target="courier_customer_distance")
model.add_factor(values=availability_probs, target="availability", parents=["maintenance", "time_of_day"])
model.add_factor(values=trip_efficiency_probs, target="trip_efficiency", parents=["trip_distance", "courier_customer_distance"])
model.add_factor(values=delivery_acceptance_probs, target="delivery_acceptance", parents=["availability", "courier_experience", "trip_efficiency"])

Our model is now prepared.

Continual learning

Continual learning refers to the idea that a model can be updated upon presentation of new data. For example, let's suppose that we collect 5000 samples of food delivery data for the above eight variables. Using this we can learn the parameters of our model ("training"). Now suppose that a few months later we want to make sure that our model is still up to date in case anything has changed in the real world. We can collect 5000 more samples and retrain the model to learn new parameter. Learning in this way, continuously, allows us to update the model taking into account the new information. We now demonstrate continual learning in both the model editor and Python SDK.

To perform continual learning the model editor, we merely need to train the model repeatedly with different batches of samples. Navigate to the menu Model > Train. A prompt will appear which will allow you to upload data. Upload the first batch which is available in the model file and sample data section of this tutorial. After training (parameter learning) the model probabilities will have changed from their initialization.

Suppose that some time has passed and another batch of data became available. To perform continual learning, you would simply train the model again with this new dataset. Each time a new batch of data is available the model can be trained again to learn the parameters.

First we import the necessary components. Remember to set your API key. Assume that the sample CSV dataset is titled bayesian_network_samples.

from genius_client_sdk.agent import GeniusAgent
from genius_client_sdk.auth import ApiKeyConfig

API_KEY = ApiKeyConfig(api_key=<YOUR-API-KEY>)
SAMPLES = "bayesian_network_samples.csv"

Next we initialize the Genius agent and load the model we created in the previous section of this tutorial.

agent_http_protocol, agent_hostname, agent_port = "http", "localhost", 3000

agent = GeniusAgent(
    agent_http_protocol=agent_http_protocol,
    agent_hostname=agent_hostname,
    agent_port=agent_port,
    auth_config=API_KEY
)

agent.load_genius_model(model=model)

First, we load the data and split it into 4 batches. This is meant to replicate the idea that we may have multiple batches of data available at different times.

dat.iloc[:5000, :].to_csv("rideshare_samples_0.csv", index=False)
dat.iloc[5000:10000, :].to_csv("rideshare_samples_1.csv", index=False)
dat.iloc[10000:15000, :].to_csv("rideshare_samples_2.csv", index=False)
dat.iloc[15000:20000, :].to_csv("rideshare_samples_3.csv", index=False)

Next, we will feed each batch to the agent for learning (training) and pull out the factor probabilities after training is complete on each batch. The first loop in the code below does not require learning because we are just extracting the initial state of the factor probabilities that we specified when we built the model in the previous section of this tutorial.

Although the code below has some extra details that will enable us to gather the data for plotting later, the key point is that each time we call agent.learn() with the same agent but pass in a different CSV, the factor probabilities will be updated.

# Loop over each data set and feed to the agent

n_factors = dat.shape[1]
csv_path_list = ["rideshare_samples_0.csv", "rideshare_samples_1.csv", "rideshare_samples_2.csv", "rideshare_samples_3.csv"]
results = {}

# Get parameter probabilities for initialization
factors = []
for f in range(n_factors):
    factors.append(agent.model.get_factor_attributes(factor_id=f, attribute="values"))
results["init"] = factors

# Loop over each data batch and learn
for n_idx, n in enumerate(csv_path_list):
    agent.learn(csv_path=n)
    
    # Loop over each factor and extract parameter probabilities
    factors = []
    for f in range(n_factors):
        factors.append(agent.model.get_factor_attributes(factor_id=f, attribute="values"))
    
    # Add all probabilities to results dict
    results[str(n_idx)] = factors

The results variable now contains the results of learning which we will analyze below.

Preparing the results for visualization

Next let's analyze the results by looking at a visualization. If you are just interested in the results you can skip this subsection.

Below is the code used to prepare the data for graphing. First we create a graph_data dictionary that initializes empty arrays that we will use to get the data in a convenient format for graphing. Then we loop over our results and add the correct results to the graph_data dict. This is necessary because the results are in terms of batches but we want to plot in terms of the different factors.

Conditional distributions are flattened into a 1-dimensional array so we can plot all the parameters in two-dimensions.

n_batches = 5

graph_data = {
    "time_of_day" : np.zeros((n_batches, *time_of_day_probs.shape)),
    "maintenance" : np.zeros((n_batches, *maintenance_probs.shape)),
    "courier_experience" : np.zeros((n_batches, *courier_experience_probs.shape)),
    "trip_distance" : np.zeros((n_batches, *trip_distance_probs.shape)),
    "courier_customer_distance" : np.zeros((n_batches, *courier_customer_distance_probs.shape)),
    "availability" : np.zeros((n_batches, *availability_probs.shape)),
    "trip_efficiency" : np.zeros((n_batches, *trip_efficiency_probs.shape)),
    "delivery_acceptance" : np.zeros((n_batches, *delivery_acceptance_probs.shape))
}

# Get keys for graph data and results
graph_data_keys = list(graph_data.keys())
results_data_keys = list(results.keys())

# Loop over batches and add results to graph data
for b in range(n_batches):
    for idx, k in enumerate(graph_data_keys):
        graph_data[k][b] = results[results_data_keys[b]][idx]

# Flatten tensors so they can be plotted
graph_data["availability"] = np.reshape(graph_data["availability"], newshape=(5, 24))
graph_data["trip_efficiency"] = np.reshape(graph_data["trip_efficiency"], newshape=(5, 18))
graph_data["delivery_acceptance"] = np.reshape(graph_data["delivery_acceptance"], newshape=(5, 24))

We will also define the ground truth probabilities. These are the true probabilities of the model. Normally this information would not be available but in this teaching example, we have designed the model with specific probabilities in mind.

""" Ground truth probabilities: Actual probabilities for the model """

# Priors
time_of_day_probs_true = np.array([0.2, 0.1, 0.1, 0.3, 0.2, 0.1])
maintenance_probs_true = np.array([0.5, 0.5])
courier_experience_probs_true = np.array([0.6, 0.4])
trip_distance_probs_true = np.array([0.4, 0.4, 0.2])
courier_customer_distance_probs_true = np.array([0.6, 0.4])

# Conditional distributions
availability_probs_true = np.array(
    [[[0, 0, 0, 0, 0, 0], [0.7, 0.7, 0.7, 0.7, 1, 1]],
     [[1, 1, 1, 1, 1, 1], [0.3, 0.3, 0.3, 0.3, 0, 0]]]
).flatten()

trip_efficiency_probs_true = np.array([[0.3, 0.6, 0.2, 0.5, 0.1, 0.4],
                                  [0.4, 0.3, 0.4, 0.3, 0.3, 0.3],
                                  [0.3, 0.1, 0.4, 0.2, 0.6, 0.3]]).flatten()

delivery_acceptance_probs_true = np.array([[1, 1, 1, 1, 1, 1, 0.8, 0.6, 0.6, 0.6, 0.4, 0.2],
                                      [0, 0, 0, 0, 0, 0, 0.2, 0.4, 0.4, 0.4, 0.6, 0.8]]).flatten()

ground_truth = [time_of_day_probs_true, maintenance_probs_true, courier_experience_probs_true, trip_distance_probs_true, courier_customer_distance_probs_true, availability_probs_true, trip_efficiency_probs_true, delivery_acceptance_probs_true]

Now we plot the data

x_labs = ["Initialization", "Batch 1", "Batch 2", "Batch 3", "Batch 4"]
factor_names = list(graph_data.keys())

fig = plt.figure()
fig, axes = plt.subplots(2, 4, facecolor=(1,1,1), figsize=(10,6))

# Loop over axes, ground truth, and factor names to plot
for idx, (g, f, ax) in enumerate(zip(ground_truth, factor_names, axes.ravel())):
    ax.plot(x_labs, graph_data[f])
    ax.scatter(["Batch 4"] * len(ground_truth[idx]), g, zorder=8, c="black")
    ax.set_title(f)
    ax.tick_params(axis='x', rotation=45)
    ax.set_ylim(0 - 0.1, 1 + 0.1)

# Axis global labels
fig.supxlabel("Batch number", fontsize=16)
fig.supylabel("Probability", fontsize=16)

# Cosmetic changes and axes ranges
for ax in axes.reshape(-1):
    ax.axes.grid(which="major", axis="both", c="#f2f2f2")
    plt.setp(ax.spines.values(), color="black", linewidth=0.5)
    ax.tick_params(
        axis='both',          
        which='major',      
        bottom=True,
        left=True,
        color="black",
        width=0.5,
        length=3)
    
fig.tight_layout()

Analyzing the results

This figure shows each factor and how the parameter probabilities change across batches. For example, "time of day" has three parameter so the three lines show how each parameter changes from initialization to each presented batch of data. For the last three factors, which are multi-dimensional, we plot each individual parameter by flattening the factor to 1 dimension. The black circles denote the ground truth values.

The results indicate that all parameters start at the specific initialization values and quickly, through learning, converge upon the correct values as more data is presented. Since the data does not change much from batch to batch, the lines are relatively flat after the first batch. If the data changed drastically, which could be the case in the real world, continual learning would automatically adjust in response to obtain the correct parameters.

Latent variable learning

Latent variables refer to variables in the model for which no data is available. In this sense, latent variables are "unobservable" or "hidden". We will use the a special version of the food delivery dataset where the trip_efficiency variable is unavailable. This dataset is provided in the model file and sample data section below.

Below, we demonstrate how latent variable learning is done in both the model editor and Python SDK:

Using the model we created above, we click on the trip_efficiency variable node and change the Role of the variable to "hidden" as shown in the image below:

Now when we perform parameter learning (training), Genius will automatically attempt to learn the parameters of the factor despite lacking the data.

First, we recreate the model from the building the model section with the following difference:

model.add_variable(
    name="trip_efficiency",
    values=["low", "medium", "high"],
    role="latent"
)

Here we let Genius know that the trip_efficiency variable is a latent variable. Now that this variable is specified as latent, we merely need to call learn with the dataset missing the trip_efficiency variables.

agent.learn(csv_path="latent_samples.csv")

Genius will now automatically attempt to learn the probabilities of this variable despite lacking data available. Since learning the presence of latent variable is more complex than learning in the fully observable case, it will take longer.

Analyzing the results

Let's examine the root mean squared error between the parameter estimates and the true probabilities. We see an RMSE of 0.158. This means that, on average, the parameters were estimated with an error 0.158 probability.

It is important to note that latent variable inference will always be approximate process and never guaranteed to converge upon the true probabilities. The more data that is available for variables interacting with these factors, the more accurate the stimation will be.

Although we were able to compare the estimate to the true probabilities in this example, note that this is not actually possible in a real world scenario. In this example we started with a complete dataset and simply removed the trip_efficiency column which enabled us to compare to the actual values.

PreviousSupply chain delays NextActive inference examples

Last updated 9 months ago

hashtagBuilding the model

hashtagContinual learning

hashtagPreparing the results for visualization

hashtagAnalyzing the results

hashtagLatent variable learning

hashtagAnalyzing the results

Building the model

Continual learning

Preparing the results for visualization

Analyzing the results

Latent variable learning

Analyzing the results