Skip to main content

Define a prescriptive scenario

In this tutorial you will learn how to create a scenario to optimize the future performance of the example business and produce prescriptive insights, you will:

  1. Create a prescriptive scenario to simulate future business outcomes, as a continuation of the past.
  2. Add the new scenario to the pipeline that already concatenates the reports descriptive and predictive scenarios together.
  3. Build layouts to update the headers to show the compare the key performance indicators
  4. Construct a prescriptive layout to observe the objective during optimization

This lesson will assume that you have an empty project and asset which you can to deploy to a workspace named 04_03_04_define_a_prescriptive_scenario with the following command:

edk template deploy -ycw 04_03_04_define_a_prescriptive_scenario

Define prescriptive scenario

In the previous lesson you created a predictive scenario to simulate the future performance of the example business, however, the simulation assumed that future decisions would be made the in the same way as historic decisions. You can enable optimization in a scenario to simulate the future performance of the example business, based on optimized future decisions.

Since you have created a value network earlier, you know the following:

  • the objective of the business is to maximize the total net cash (cash balance + liabilities)
  • the two decisions made in the business that could be optimized are:
    • the price of the product
    • the supplier of the product in each order

You can use the above to configure a prescriptive scenario, with the following steps:

  1. create a new ScenarioBuilder with a name
  2. define the Predictive scenario as the continuation of the Descriptive scenario
  3. add resources to the scenario, which are the predicted orders
  4. add processes to the scenario, which are the predicted sales and procurement processes
  5. add an alterResourceFromValue statement to the scenario, to clear the reports
  6. add an endSimulation statement to the scenario, to end the simulation at the end date
  7. add an objective statement to the scenario, to maximize the total net cash (cash balance + liabilities)
  8. add a statement to optimize the Price, to find the price that will maximize the objective
  9. add a statement to optimize supplierName in every Orders, to find the price that will maximize the objective
  10. configure optimization to:
    1. run in memory (running in memory is faster, but requires more memory)
    2. run for 2500 iterations (its allowed to run simulation this many times)
    3. run 5 trajectories (configure simulation to use 5 monte carlo trajectories)

In the code add the above changes:

// create a scenario to simulate and optimize future events
const prescriptive = new ScenarioBuilder("Prescriptive")
    .continueScenario(descriptive)
    .resource(orders)
    .process(predicted_sales)
    .process(predicted_procurement)
    // reset the reports
    .alterResourceFromValue("Reports", new Map())
    // end simulation at the end date
    .endSimulation(end_date.outputStream())
    // maximize the total net cash (cash balance + liabilities)
    .objective(resources => Add(resources.Cash, resources.Liability))
    // find the best price to provide to customers
    .optimize("Price", { min: rrp * 0.7, max: rrp, })
    // for every scheduled order, find the best supplier to order from
    .optimizeEvery("Orders", "supplierName", {
        // for any order the supplier can be any one of the suppliers
        range: (resources) => ToArray(Keys(resources.Suppliers))
    })
    // since its a small optimization problem, we can run in memory
    .optimizationInMemory(true)
    // force the optimization to run for 2500 iterations
    .optimizationMaxIterations(2500)
    .optimizationMinIterations(2500)
    // since there is uncertainty in the demand, run multiple trajectories
    .optimizationTrajectories(5)
Scenario optimization

With an optimized scenario, you can access the optimization iterations with the following stream:

  • optimizationStream(): Return a stream detailing the optimization procedure, where convergence of optimization can be validated.
Optimization convergence

Optimization will automatically select an appropriate optimization algorithm, based on the problem, and will run until convergence. It's important to note that for a real business, detecting convergence is difficult, and it's recommended to run optimization for a fixed number of iterations, or for a fixed amount of time.

The number of iterations required for convergence is dependent on the complexity of the business (simulation), the level of uncertainty in the business, and the number of decision points being optimized, and the number of trajectories. Where possible it is recommended to reduce the number of decision points where possible to avoid the exploding complexity due to high dimensionality.

Update report concatenation

To include the prescriptive scenario in the report visuals, you can add the prescriptive scenario to the report concatenation pipeline, with the following steps:

  1. add an input to the pipeline, which is the reports from the Prescriptive scenario
  2. update the concatenate operation
    1. add an inputs to the concatenate operation, which is the reports from the Prescriptive scenario

In the code add the above changes:

// combine the reports from all multiple scenarios
const concatenated_reports = new PipelineBuilder("Concatenated Reports")
    .from(descriptive.simulationResultStreams().Reports)
    // filter the historic data to include one week in the past
    .input({ name: "next", stream: sales_dates.outputStreams().next })
    .filter((fields, _key, inputs) => GreaterEqual(fields.date, SubtractDuration(inputs.next, 1, 'week')))
    // combine the reports from the future scenarios
    .input({ name: "Optimized", stream: prescriptive.simulationResultStreams().Reports })
    .input({ name: "BAU", stream: predictive.simulationResultStreams().Reports })
    .concatenate({
        discriminator_name: "scenario",
        discriminator_value: "Historic",
        inputs: [
            { input: inputs => inputs.Optimized, discriminator_value: "Optimized" },
            { input: inputs => inputs.BAU, discriminator_value: "BAU" },
        ]
    })

Update dashboard

Finally, you can update the dashboard to display kpi values comparing the Predictive and Prescriptive scenarios.

Define kpi headers

To add a kpi to the dashboard you can use a kpi header item, with the following steps:

  1. replace the Profit item with a new Profit (% Full Potential) item, which will compare the profits
    1. add an input to the item, which is the cash from the Prescriptive scenario
    2. add the Predictive as the value of the item
    3. add the Prescriptive as the target of the item
    4. add a comparison to the item, comparing the two scenarios
    5. add a goal to the item, which is greater

In the code add the above changes:

// create a dashboard to interact with the simulation and optimization
const dashboard = new LayoutBuilder("Dashboard")
    .panel(
        "row",
        builder => builder
            .tab(40, builder => builder
                .layout(orders_graph)
                .layout(supplier_graph)
            )
            .tab(60, builder => builder
                .layout(cash_graph)
                .layout(liability_graph)
                .layout(inventory_graph)
            )
    )
    .header(
        builder => builder
            .item(
                "Price",
                builder => builder
                    .fromStream(predictive.simulationResultStreams().Price)
                    .value((value) => PrintTruncatedCurrency(value))
            )
            .item(
                "Profit (% Full Potential)",
                builder => builder
                    // add a kpi to the header, with the cash value, target, comparison and goal
                    .fromStream(prescriptive.simulationResultStreams().Cash)
                    .input({ name: "interactive", stream: predictive.simulationResultStreams().Cash })
                    .kpi({
                        value: (_value, inputs) => PrintTruncatedCurrency(inputs.interactive),
                        target: (value) => PrintTruncatedCurrency(value),
                        comparison: (value, inputs) => Compare(inputs.interactive, value),
                        goal: 'greater'
                    })
            )
    )

Repeat similar steps for the Inventory and Liability header items.

Define optimization layout

You may also want to visualise the objective from optimization, to do this you can use an objective layout, with the following code:

// use a pre-made objective chart 
const objective = ObjectiveLayout("Prescriptive", prescriptive.optimizationStream())

Congratulations, you have now created a prescriptive scenario to optimize future business outcomes. Deploy the project to see significant the improvements in the business performance.

Example Solution

The final solution for this tutorial is available below:

Next Steps

In the next lesson, you will learn how to interact with a scenario and create interactive insights.

On this page