Build and Deploy Your First Supply Chain App in 20 Minutes

, it’s simple to make an impression along with your knowledge science and analytics expertise.

Even when knowledge high quality stays a difficulty more often than not, you could find alternatives to unravel issues by offering insights to operational groups.

Operations Supervisor: “What number of momentary employees ought to I recruit subsequent to satisfy our workforce demand on the lowest price?

Once I was a Provide Chain Resolution Supervisor in a logistics firm, I discovered knowledge science by making use of mathematical rules to unravel operational issues in our warehouses.

It was very archaic.

I used to be operating Python scripts or Jupyter notebooks on my machine and sharing the outcomes with my colleagues.

Till I found Streamlit, which let me effortlessly package deal my fashions into internet purposes that I might simply deploy.

That is essential for any provide chain course of engineer or knowledge scientist to discover ways to productise analytics instruments.

The way to rework Python code into actionable insights?

On this article, I’ll present you find out how to rework a simulation mannequin in-built Jupyter Pocket book into a completely functioning internet software.

This train was a part of a tutorial collection on my YouTube Channel, during which we use Python to be taught Stock Administration in Provide Chain.

You’ll find out how I took a core module written in Python scripts to construct an interactive software with which you’ll:

• Simulate a number of stock administration guidelines
• Check a number of situations with totally different supply lead occasions (LD in days), demand variability (sigma in items) and cycle time (T in days)

If you’re not acquainted with these ideas, you may nonetheless observe this tutorial, as I’ll briefly introduce them within the first part.

Or you may instantly bounce into the second part that focuses solely on the creation and deployment of the app.

Stock Administration Simulation with Python

What’s stock administration?

Most retailers I’ve labored with in Asia and Europe handle retailer orders with rule-based strategies constructed into their ERPs.

When do that you must replenish your shops to keep away from stock-outs?

These guidelines are normally carried out in an Enterprise Useful resource Planning (ERP) software program that sends orders to a Warehouse Administration System (WMS).

The purpose is to develop a coverage that minimises ordering, holding and absence prices.

• Ordering Prices: mounted price to position an order
• Holding Prices: variable prices required to maintain your stock (storage and capital prices)
• Scarcity Prices: the prices of not having sufficient stock to satisfy the client demand (Misplaced Gross sales, Penalty)

We’ll act as knowledge scientists in a retail firm and assess the effectivity of the stock crew’s guidelines.

Logistics Director: “Samir, we’d like your help to know why some shops face stockouts whereas different have an excessive amount of stock.”

For that, we’d like a software to simulate a number of situations and visualise the impression of key parameters on prices and inventory availability.

Within the chart above, you have got an instance of a rule with:

• A uniform demand distribution (i.e σ = 0)
  Day by day, your retailer will promote the identical variety of objects.
• A periodic overview coverage with T = 10 days
  You replenish the shops each 10 days.
• A supply lead time of LD = 1 day.
  In the event you order right now, you’ll obtain the products tomorrow.

As you may see within the inexperienced chart, your stock on-hand (IOH) is all the time constructive (i.e. you don’t expertise stock-outs).

1. What when you have a 3-day lead time?
2. What can be the impression of variability within the demand (σ > 0)?
3. Can we scale back the typical stock readily available?

To reply these questions, I developed a simulation mannequin utilizing Jupyter Pocket book to generate visuals in a complete tutorial.

On this article, I’ll briefly introduce the core features I constructed on this tutorial and present how we’ll reuse them in our Streamlit app.

Observe: I’ll hold explanations high-level to deal with the Streamlit app. For particulars, you may watch the total video later.

Your Stock Simulation Software in a Jupyter Pocket book

The outcomes of this tutorial will function the core basis of our Stock Simulation Streamlit App.

The venture construction is fundamental with two Python recordsdata (.py) and a Jupyter Pocket book.

tuto_inventory /
├─ Stock Administration.ipynb
└─ stock/
├─ init.py
├─ inventory_analysis.py
└─ inventory_models.py

In inventory_models.py, you could find a Pydantic class that comprises all of the enter parameters for our simulation.

from typing import Non-compulsory, Literal
from pydantic import BaseModel, Discipline


class InventoryParams(BaseModel):
    """Base financial & demand parameters (deterministic day by day demand)."""
    D: float = Discipline(2000, gt=0, description="Annual demand (items/yr)")
    T_total: int = Discipline(365, ge=1, description="Days in horizon (normally 365)")
    LD: int = Discipline(0, ge=0, description="Lead time (days)")
    T: int = Discipline(10, ge=1, description="Cycle time (days)")
    Q: float = Discipline(0, ge=0, description="Order amount (items)")
    initial_ioh: float = Discipline(0, description="Preliminary stock readily available")
    sigma: float = Discipline(0, ge=0, description="Customary deviation of day by day demand (items/day)")

These operational parameters cowl

• Demand Distribution: the entire demand D (pcs), our simulation horizon T_total (pcs) and the variability σ (pcs)
• Logistics Operations: with the supply lead time LD (in days)
• Stock rule parameters: together with the cycle time T, order amount Q and the preliminary stock readily available initial_ioh

Based mostly on these parameters, we wish to simulate the impression on our distribution chain:

• Demand distribution: what number of items did we promote?
• Stock On-Hand in inexperienced: what number of items do we’ve within the retailer?
• Replenishment orders in blue: when and the way a lot have we ordered?

Within the instance above, you see a simulation of a periodic overview coverage with a 10-day cycle time.

How did I generate these visuals?

These features are simulated utilizing the category InventorySimulation created in inventory_analysis.py.

class InventorySimulation:
    def __init__(self, 
                 params: InventoryParams):
        self.sort = sort
        self.D = params.D
        self.T_total = params.T_total
        self.LD = params.LD
        self.T = params.T
        self.Q = params.Q
        self.initial_ioh = params.initial_ioh
        self.sigma = params.sigma
        
        # # Demand per day (unit/day)
        self.D_day = self.D / self.T_total
        
        # Simulation dataframe
        self.sim = pd.DataFrame({'time': np.array(vary(1, self.T_total+1))})

We begin by initialising the enter parameters for the features:

• order() which represents a periodic ordering coverage (you order Q items each T days)
• simulation_1() that calculates the impression of the demand (gross sales) and the ordering coverage on the stock readily available every day

class InventorySimulation:
    ''' [Beginning of the class] ''' 
    def order(self, t, T, Q, start_day=1):
        """Order Q beginning at `start_day`, then each T days."""
        return Q if (t > start_day and ((t-start_day) % T) == 0) else 0
    def simulation_1(self):
        """Mounted-cycle ordering; lead time NOT compensated."""
        sim_1 = self.sim.copy()
        sim_1['demand'] = np.random.regular(self.D_day, self.sigma, self.T_total)
        T = int(self.T)
        Q = float(self.Q)
        sim_1['order'] = sim_1['time'].apply(lambda t: self.order(t, T, Q))
        LD = int(self.LD)
        sim_1['receipt'] = sim_1['order'].shift(LD, fill_value=0.0)
        # Stock: iterative replace to respect lead time
        ioh = [self.initial_ioh]
        for t in vary(1, len(sim_1)):
            new_ioh = ioh[-1] - sim_1.loc[t, 'demand']
            new_ioh += sim_1.loc[t, 'receipt']
            ioh.append(new_ioh)
        sim_1['ioh'] = ioh
        for col in ['order', 'ioh', 'receipt']:
            sim_1[col] = np.rint(sim_1[col]).astype(int)
        return sim_1 

The perform simulation_1() features a mechanism that updates stock on-hand primarily based on retailer demand (gross sales) and provide (replenishment orders).

My purpose for this tutorial was to begin with two fundamental guidelines to elucidate what occurs if you introduce a lead time, as proven under.

Shops expertise stock-outs, as proven within the inexperienced chart.

Their on-hand stock turns into destructive attributable to late deliveries.

What can we do? Perhaps rising the order amount Q?

That is what I attempted within the tutorial; we found that this resolution doesn’t work.

These two situations highlighted the necessity for an improved ordering coverage that compensates for lead occasions.

That’s what we constructed within the second a part of the tutorial with these two extra features.

class InventorySimulation:
    ''' [Beginning of the class] ''' 

    def order_leadtime(self, t, T, Q, LD, start_day=1):
        return Q if (t > start_day and ((t-start_day + (LD-1)) % T) == 0) else 0

    def simulation_2(self, technique: Non-compulsory[str] = "order_leadtime"):
        """Mounted-cycle ordering; lead time NOT compensated."""
        sim_1 = self.sim.copy()
        LD = int(self.LD)
        sim_1['demand'] = np.most(np.random.regular(self.D_day, self.sigma, self.T_total), 0)
        T = int(self.T)
        Q = float(self.Q)
        if technique == "order_leadtime":
            sim_1['order'] = sim_1['time'].apply(lambda t: self.order_leadtime(t, T, Q, LD))
        else:
            sim_1['order'] = sim_1['time'].apply(lambda t: self.order(t, T, Q))
        sim_1['receipt'] = sim_1['order'].shift(LD, fill_value=0.0)
        # Stock: iterative replace to respect lead time
        ioh = [self.initial_ioh]
        for t in vary(1, len(sim_1)):
            new_ioh = ioh[-1] - sim_1.loc[t, 'demand']
            new_ioh += sim_1.loc[t, 'receipt']
            ioh.append(new_ioh)
        sim_1['ioh'] = ioh
        for col in ['order', 'ioh', 'receipt']:
            sim_1[col] = np.rint(sim_1[col]).astype(int)
        return sim_1   

The thought is kind of easy.

In observe, which means stock planners should create replenishment orders at day = T – LD to compensate for the lead time.

This ensures shops obtain their items on day = T as proven within the chart above.

On the finish of this tutorial, we had a whole simulation software that permits you to take a look at any state of affairs to grow to be acquainted with stock administration guidelines.

In the event you want extra clarification, you could find detailed explanations in this step-by-step YouTube tutorial:

Nonetheless, I used to be not glad with the end result.

Why do we have to package deal this in an internet software?

Productising This Simulation Software

As you may see within the video, I manually modified the parameters within the Jupyter pocket book to check totally different situations.

That is considerably regular for knowledge scientists like us.

However, would you think about our Logistics Director opening a Jupyter Pocket book in VS Code to check the totally different situations?

We have to productise this software so anybody can entry it with out requiring programming or knowledge science expertise.

Excellent news, 70% of the job is finished as we’ve the core modules.

Within the subsequent part, I’ll clarify how we are able to package deal this in a user-friendly analytics product.

Create your Stock Simulation App utilizing Streamlit

On this part, we’ll create a single-page Streamlit App primarily based on the core module from the primary tutorial.

You can begin by cloning this repository that comprises the core simulation, together with inventory_models.py and inventory_analysis.py.

With this repository in your native machine, you may observe the tutorial and find yourself with a deployed app like this one:

Let’s begin!

Venture Setup

Step one is to create a neighborhood Python surroundings for the venture.

For that, I counsel you to make use of the package deal supervisor uv:

# Create a digital surroundings and activate it
uv init
uv venv
supply .venv/bin/activate

# Set up
uv pip set up -r necessities.txt

It’ll set up the libraries listed within the necessities file:

streamlit>=1.37
pandas>=2.0
numpy>=1.24
matplotlib>=3.7
pydantic>=2.0

We embrace Streamlit, Pydantic, and libraries for knowledge manipulation (numpy, pandas) and for producing visuals (matplotlib).

Now you’re able to construct your app.

Create your Streamlit Web page

Create a Python file that you simply name: app.py

import numpy as np
import matplotlib.pyplot as plt
import streamlit as st
from stock.inventory_models import InventoryParams
from stock.inventory_analysis import InventorySimulation
seed = 1991
np.random.seed(seed)

st.set_page_config(page_title="Stock Simulation – Streamlit", structure="large")

On this file, we begin by:

• Importing the libraries put in and the evaluation module with its Pydantic class for the enter parameters
• Defining a seed for random distribution technology that shall be used to generate a variable demand

Then we begin to create the web page with st.set_page_config(), during which we embrace as parameters:

• page_title: the title of the online web page of your app
• structure: an choice to set the structure of the web page

By setting the parameter structure to “large”, we make sure the web page is large by default.

You possibly can run your app now,

streamlit run app.py

After operating this command, your app might be opened utilizing the native URL shared in your terminal:

After loading, what you have got is that this clean web page:

Congratulations, you have got run your app!

In the event you face any points at this stage, please examine that:

• The native Python surroundings is about up correctly
• You will have put in all of the libraries inside the necessities file

Now we are able to begin constructing our Stock Administration App.

A Sidebar with Stock Administration Parameters

Do you bear in mind the Pydantic class we’ve outlined in inventory_models.py?

They may function our enter parameters for the app, and we’ll show them in a Streamlit sidebar.

with st.sidebar:
    st.markdown("**Stock Parameters**")
    D = st.number_input("Annual demand D (items/yr)", min_value=1, worth=2000, step=50)
    T_total = st.number_input("Horizon T_total (days)", min_value=1, worth=365, step=1)
    LD = st.number_input("Lead time LD (days)", min_value=0, worth=0, step=1)
    T = st.number_input("Cycle time T (days)", min_value=1, worth=10, step=1)
    Q = st.number_input("Order amount Q (items)", min_value=0.0, worth=55.0, step=10.0, format="%.2f")
    initial_ioh = st.number_input("Preliminary stock readily available", min_value=0.0, worth=55.0, step=1.0, format="%.2f")
    sigma = st.number_input("Each day demand std. dev. σ (items/day)", min_value=0.0, worth=0.0, step=0.5, format="%.2f")
    technique = st.radio(
        "Ordering technique",
        choices=["Simple Ordering", "Lead-time Ordering"],
        index=0
    )
    method_key = "order_leadtime" if technique.startswith("Lead-time") else "order"
    
    run = st.button("Run simulation", sort="main")
    if run:
        st.session_state.has_run = True

On this sidebar, we embrace:

• A title utilizing st.markdown()
• Quantity Enter fields for all of the parameters with their minimal, default, and incremental step values
• A radio button to pick the ordering technique (contemplating or not lead time)
• A button to begin the primary simulation

Earlier than this block, we must always add a session state variable:

if "has_run" not in st.session_state:
    st.session_state.has_run = False

This boolean signifies whether or not the consumer has already clicked the simulation button.

If that’s the case, the app will routinely rerun all calculations each time the consumer adjustments a parameter.

Nice, now you app.py ought to appear to be this:

import numpy as np
import matplotlib.pyplot as plt
import streamlit as st
from stock.inventory_models import InventoryParams
from stock.inventory_analysis import InventorySimulation
seed = 1991
np.random.seed(seed)

st.set_page_config(page_title="Stock Simulation – Streamlit", structure="large")

if "has_run" not in st.session_state:
    st.session_state.has_run = False

with st.sidebar:

    st.markdown("**Stock Parameters**")
    D = st.number_input("Annual demand D (items/yr)", min_value=1, worth=2000, step=50)
    T_total = st.number_input("Horizon T_total (days)", min_value=1, worth=365, step=1)
    LD = st.number_input("Lead time LD (days)", min_value=0, worth=0, step=1)
    T = st.number_input("Cycle time T (days)", min_value=1, worth=10, step=1)
    Q = st.number_input("Order amount Q (items)", min_value=0.0, worth=55.0, step=10.0, format="%.2f")
    initial_ioh = st.number_input("Preliminary stock readily available", min_value=0.0, worth=55.0, step=1.0, format="%.2f")
    sigma = st.number_input("Each day demand std. dev. σ (items/day)", min_value=0.0, worth=0.0, step=0.5, format="%.2f")
    technique = st.radio(
        "Ordering technique",
        choices=["Simple Ordering", "Lead-time Ordering"],
        index=0
    )
    method_key = "order_leadtime" if technique.startswith("Lead-time") else "order"
    
    run = st.button("Run simulation", sort="main")
    if run:
        st.session_state.has_run = True

You possibly can take a look at your app, usually the window ought to appear to be this after a refresh:

On the left, you have got your sidebar that we simply created.

Then, for aesthetics and consumer expertise, I wish to add a title and a reminder of the parameters used.

Why do I wish to remind the parameters used?

On the top-left aspect of the window, you have got a button to cover the aspect panel, as proven under.

This helps customers to have more room to indicate the visible.

Nonetheless, the enter parameters shall be hidden.

Due to this fact, we have to add a reminder on the prime.

st.title("Stock Simulation Internet Utility")
# Chosen Enter Parameters
D_day = D / T_total
st.markdown("""
<type>
.quick-card{padding:.9rem 1rem;border:1px strong #eaeaea;border-radius:12px;background:#fff;box-shadow:0 1px 2px rgba(0,0,0,.03)}
.quick-card .label{font-size:.85rem;coloration:#5f6b7a;margin:0}
.quick-card .worth{font-size:1.25rem;font-weight:700;margin:.15rem 0 0 0;coloration:#111}
.quick-card .unit{font-size:.8rem;coloration:#8a95a3;margin:0}
</type>
""", unsafe_allow_html=True)

def quick_card(label, worth, unit=""):
    unit_html = f'<p class="unit">{unit}</p>' if unit else ""
    st.markdown(f'<div class="quick-card"><p class="label">{label}</p><p class="worth">{worth}</p>{unit_html}</div>', unsafe_allow_html=True)

Within the piece of code above, I’ve launched :

• CSS styling embedded in Streamlit to create playing cards
• The perform quick_card will create a card for every parameter utilizing its label, worth and items

Then we are able to generate these playing cards in the identical row utilizing the streamlit object st.columns().

c1, c2, c3, c4, c5, c6 = st.columns(6)
with c1:
    quick_card("Common day by day demand", f"{D_day:,.2f}", "items/day")
with c2:
    quick_card("Lead time", f"{LD}", "days")
with c3:
    quick_card("Cycle time", f"{T}", "days")
with c4:
    quick_card("Order amount Q", f"{Q:,.0f}", "items")
with c5:
    quick_card("Preliminary IOH", f"{initial_ioh:,.0f}", "items")
with c6:
    quick_card("Demand σ", f"{sigma:.2f}", "items/day")

The primary line defines the six columns during which we place the playing cards utilizing the quick_card perform.

We are able to transfer on to the attention-grabbing half: integrating the simulation software into the app.

Any query or blocking at this step? You should use the remark part of the video, I’ll strive my finest to reply promptly.

Integrating the stock simulation module within the Streamlit App

We are able to now begin engaged on the principle web page.

Allow us to think about that our Logistics Director arrives on the web page, selects the totally different parameters and clicks on “Run Simulation”.

This could set off the simulation module:

if st.session_state.has_run:
    params = InventoryParams(
        D=float(D),
        T_total=int(T_total),
        LD=int(LD),
        T=int(T),
        Q=float(Q),
        initial_ioh=float(initial_ioh),
        sigma=float(sigma)
    )

    sim_engine = InventorySimulation(params)

On this quick piece of code, we do many issues:

• We construct the enter parameter object utilizing the Pydantic class from inventory_models.py
  This ensures each worth (demand, lead time, overview interval, sigma…) has the proper knowledge sort earlier than operating the simulation.
• We create the simulation engine InventorySimulation class from inventory_analysis.py
  This class comprises all of the stock logic I developed within the first tutorial.

Nothing will change on the consumer interface.

We are able to now begin to outline the computation half.

if st.session_state.has_run:
    ''' [Previous block introduced above]'''
    if method_key == "order_leadtime":
        df = sim_engine.simulation_2(technique="order_leadtime")
    elif method_key == "order":
        df = sim_engine.simulation_2(technique="order")
    else:
        df = sim_engine.simulation_1()

    # Calculate key parameters that shall be proven under the visible
    stockouts = (df["ioh"] < 0).sum()
    min_ioh = df["ioh"].min()
    avg_ioh = df["ioh"].imply()

First, we choose the proper ordering technique.

Relying on the ordering rule chosen within the radio button of the sidebar, we name the suitable simulation technique:

• technique=”order”: is the preliminary technique that I confirmed you, which did not hold a steady stock after I added a lead time
• technique=”order_leadtime”: is the improved technique that orders at day = T – LD

The outcomes, saved within the pandas dataframe, df are used to compute key indicators such because the variety of stockouts and the minimal and most stock ranges.

Now that we’ve simulation outcomes accessible, let’s create our visuals.

Create Stock Simulation Visuals on Streamlit

In the event you adopted the video model of this tutorial, you most likely observed that I copied and pasted the code from the pocket book created within the first tutorial.

if st.session_state.has_run:
    '''[Previous Blocks introduced above]'''
    # Plot
    fig, axes = plt.subplots(3, 1, figsize=(9, 4), sharex=True)  # ↓ from (12, 8) to (9, 5)
    # Demand
    df.plot(x='time', y='demand', ax=axes[0], coloration='r', legend=False, grid=True)
    axes[0].set_ylabel("Demand", fontsize=8)
    # Orders
    df.plot.scatter(x='time', y='order', ax=axes[1], coloration='b')
    axes[1].set_ylabel("Orders", fontsize=8); axes[1].grid(True)
    # IOH
    df.plot(x='time', y='ioh', ax=axes[2], coloration='g', legend=False, grid=True)
    axes[2].set_ylabel("IOH", fontsize=8); axes[2].set_xlabel("Time (day)", fontsize=8)
    # Widespread x formatting
    axes[2].set_xlim(0, int(df["time"].max()))
    for ax in axes:
        ax.tick_params(axis='x', rotation=90, labelsize=6)
        ax.tick_params(axis='y', labelsize=6)
    plt.tight_layout()

Certainly, the identical visible code that you simply use to prototype in your Notebooks will work in your app.

The one distinction is that as a substitute of utilizing plt.present(), you conclude the part with:

st.pyplot(fig, clear_figure=True, use_container_width=True)  

Streamlit must explicitly management of the rendering utilizing

• fig which is the Matplotlib determine you created earlier.
• clear_figure=True which is a parameter to clear the determine from reminiscence after rendering to keep away from duplicated plots when parameters are up to date.
• use_container_width=True to make the chart routinely resize to the width of the Streamlit web page

At this stage, usually you have got this in your app:

In the event you attempt to change any parameter, for instance, change the ordering technique, you will note the visible routinely up to date.

What’s remaining?

As a bonus, I added a piece that can assist you uncover extra functionalities of streamlit.

if st.session_state.has_run:
    '''[Previous Blocks introduced above]'''
    # Key parameters offered under the visible
    kpi_cols = st.columns(3)
    kpi_cols[0].metric("Stockout days", f"{stockouts}")
    kpi_cols[1].metric("Min IOH (items)", f"{min_ioh:,.0f}")
    kpi_cols[2].metric("Avg IOH (items)", f"{avg_ioh:,.0f}")

    # Message of data
    st.success("Simulation accomplished.")

Along with the columns that we already outlined within the earlier part, we’ve:

• metric() that generates a clear and built-in Streamlit card
  In contrast to my customized card, you don’t want CSS right here.
• st.success() to show a inexperienced success banner to inform the consumer that the outcomes have been up to date.

That is the cherry on the cake that we wanted to conclude this app.

You now have a whole app that routinely generates visuals and simply exams situations, working in your machine.

What about our Logistics Director? How he can use it?

Let me present you find out how to deploy it free of charge on Streamlit Group Cloud simply.

Deploy your App on Streamlit Group

You first must push your code to your GitHub, as I did right here: GitHub Repository.

You then go to the highest proper of your app, and also you click on on Deploy.

Then click on Deploy now, and observe the steps to offer entry to your GitHub account (Streamlit will routinely detect that you’ve pushed your code to GitHub).

You possibly can create a customized URL: mine is supplyscience.

After clicking on Deploy, Streamlit will redirect you to your deployed app!

Congratulations, you have got deployed your first Provide Chain Analytics Streamlit App!

Any query? Be happy to check the complete tutorial.

Be happy to make use of the remark to ask your questions or share what you deployed on Streamlit.

Conclusion

I designed this tutorial for the model of myself from 2018.

Again then, I knew sufficient Python and analytics to construct optimisation and simulation instruments for my colleagues, however I didn’t but know find out how to flip them into actual merchandise.

This tutorial is step one in your journey towards industrialising analytics options.

What you constructed right here might be not production-ready, however it’s a useful app that you could share with our Logistics Director.

Do you want inspiration for different purposes?

The way to Full this App?

Now that you’ve the playbook for deploying Provide Chain Analytics apps, you most likely wish to enhance the app by including extra fashions.

I’ve a suggestion for you.

You possibly can observe this step-by-step tutorial to implement Product Segmentation with Pareto Analysis and ABC Chart.

You’ll discover ways to deploy strategic visuals just like the ABC XYZ that assist retail firms handle their stock.

This may be simply carried out on the second web page of the app that you simply simply deployed.

If wanted, I can work on one other article specializing in this resolution!

Bored with stock administration?

You will discover 80+ case research of AI & analytics merchandise to help Provide Chain Optimisation, Enterprise Profitability and Course of Automation in this cheat sheet.

For a lot of the case research, revealed in In direction of Knowledge Science, you could find the supply code that may be carried out in a Streamlit app.

About Me

Let’s join on Linkedin and Twitter. I’m a Provide Chain Engineer who makes use of knowledge analytics to enhance logistics operations and scale back prices.

For consulting or recommendation on analytics and sustainable provide chain transformation, be happy to contact me through Logigreen Consulting.

If you’re considering Knowledge Analytics and Provide Chain, take a look at my web site.

Samir Saci | Data Science & Productivity