Узнайте, как превратить ваши имитационные модели на Jupyter Notebooks в общие веб-приложения Streamlit с помощью этого комплексного руководства.
Делиться
В сфере управления цепочками поставок вы легко сможете добиться успеха, используя свои навыки в области науки о данных и аналитики.
Даже если качество данных в большинстве случаев остается проблемой, вы можете найти возможности для решения проблем, предоставляя информацию операционным группам.
Менеджер по операциям: «Сколько временных работников мне следует нанять, чтобы удовлетворить наш спрос на рабочую силу с минимальными затратами?
Работая менеджером по решениям для цепочки поставок в логистической компании, я изучал науку о данных, применяя математические принципы для решения операционных проблем на наших складах.
Это было очень архаично.
Я запускал скрипты Python или блокноты Jupyter на своей машине и делился результатами с коллегами.
Пока я не открыл для себя Streamlit , который позволил мне без труда упаковывать мои модели в веб-приложения, которые я мог легко развернуть.
Для любого инженера-технолога цепочки поставок или специалиста по обработке данных крайне важно научиться превращать аналитические инструменты в продукт .
Как преобразовать код Python в практические идеи?
В этой статье я покажу вам, как преобразовать имитационную модель, созданную в Jupyter Notebook , в полнофункциональное веб-приложение.
Это упражнение является частью серии обучающих видео на моем канале YouTube, в которых мы используем Python для изучения управления запасами в цепочке поставок.
Вы узнаете, как я взял основной модуль, написанный на скриптах Python, и создал интерактивное приложение, с помощью которого вы сможете:
- Моделировать несколько правил управления запасами
- Протестируйте несколько сценариев с различными сроками поставки (LD в днях), изменчивостью спроса (сигма в штуках) и временем цикла (T в днях)
Если вы не знакомы с этими концепциями, вы все равно можете следовать этому руководству, поскольку я кратко представлю их в первом разделе.
Или вы можете сразу перейти ко второму разделу , который посвящен только созданию и развертыванию приложения.
Моделирование управления запасами с помощью Python
Что такое управление запасами?
Большинство розничных продавцов, с которыми я работал в Азии и Европе, управляют заказами в магазинах с помощью методов на основе правил, встроенных в их ERP-системы.
Когда необходимо пополнять запасы, чтобы избежать дефицита?
Эти правила обычно реализуются в программном обеспечении для планирования ресурсов предприятия (ERP), которое отправляет заказы в систему управления складом (WMS).
Цель состоит в том, чтобы разработать политику, которая минимизирует затраты на заказ, хранение и устранение дефицита.
- Стоимость заказа : фиксированная стоимость размещения заказа
- Затраты на хранение: переменные затраты, необходимые для хранения ваших запасов (хранение и капитальные затраты)
- Затраты на дефицит: затраты, связанные с нехваткой запасов для удовлетворения спроса клиентов (потерянные продажи, штрафы)
Мы выступим в роли специалистов по обработке данных в розничной компании и оценим эффективность правил группы по инвентаризации.
Директор по логистике: «Самир, нам нужна ваша поддержка, чтобы понять, почему в некоторых магазинах наблюдается дефицит товаров, а в других — избыток запасов».
Для этого нам нужен инструмент для моделирования множественных сценариев и визуализации влияния ключевых параметров на затраты и доступность запасов.
На приведенной выше диаграмме представлен пример правила со следующими параметрами:
- Равномерное распределение спроса (т.е. σ = 0)
Каждый день ваш магазин будет продавать одинаковое количество товаров. - Политика периодического обзора с T = 10 дней
Вы пополняете запасы каждые 10 дней. - Срок поставки LD = 1 день.
Если вы сделаете заказ сегодня, вы получите товар завтра.
Как вы видите на зеленой диаграмме, ваши запасы на складе (IOH) всегда положительные (т.е. вы не испытываете дефицита запасов).
- А что делать, если срок поставки составляет 3 дня?
- Каким будет влияние изменчивости спроса (σ > 0)?
- Можно ли уменьшить средний размер имеющихся запасов?
Чтобы ответить на эти вопросы, я разработал имитационную модель с использованием Jupyter Notebook для создания визуальных эффектов в полноценном руководстве.
В этой статье я кратко расскажу об основных функциях, которые я создал в этом руководстве, и покажу, как мы будем их повторно использовать в нашем приложении Streamlit.
Примечание: я буду объяснять всё в общих чертах, чтобы сосредоточиться на приложении Streamlit. Подробности вы сможете посмотреть в полном видео позже.
Ваш инструмент моделирования инвентаря в Jupyter Notebook
Результаты этого руководства лягут в основу нашего приложения Streamlit для моделирования инвентаризации .
Структура проекта базовая и состоит из двух файлов Python (.py) и Jupyter Notebook .
tuto_inventory / ├─ Управление запасами.ipynb └─ inventory/ ├─ init.py ├─ inventory_analysis.py └─ inventory_models.py
В inventory_models.py вы можете найти класс Pydantic, содержащий все входные параметры для нашего моделирования.
из ввода import Optional, Literal из pydantic import BaseModel, Field class InventoryParams(BaseModel): «»»Базовые экономические параметры и параметры спроса (детерминированный ежедневный спрос).»»» D: float = Field(2000, gt=0, description=»Годовой спрос (единиц/год)») T_total: int = Field(365, ge=1, description=»Дней в горизонте (обычно 365)») LD: int = Field(0, ge=0, description=»Срок выполнения заказа (дней)») T: int = Field(10, ge=1, description=»Время цикла (дней)») Q: float = Field(0, ge=0, description=»Количество заказа (единиц)») initial_ioh: float = Field(0, description=»Начальный запас в наличии») sigma: float = Field(0, ge=0, description=»Стандартное отклонение ежедневного спрос (ед./день)»)
Эти эксплуатационные параметры охватывают
- Распределение спроса : общий спрос D (шт.), наш горизонт моделирования T_total (шт.) и изменчивость σ (шт.)
- Логистические операции : со сроком поставки LD (в днях)
- Параметры правила инвентаризации : включая время цикла T, объем заказа Q и начальный запас на складе initial_ioh
На основе этих параметров мы хотим смоделировать воздействие на нашу цепочку распределения:
- Распределение спроса: сколько единиц продукции мы продали?
- Остаток на складе обозначен зеленым цветом: сколько единиц товара есть в магазине?
- Заказы на пополнение выделены синим цветом: когда и сколько мы заказали?
В приведенном выше примере вы видите моделирование политики периодического пересмотра с 10-дневным циклом.
Как я создал эти визуальные эффекты?
Эти функции моделируются с помощью класса InventorySimulation, созданного в inventory_analysis.py.
class InventorySimulation: def __init__(self, params: InventoryParams): self.type = type 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 # # Спрос в день (единицы/день) self.D_day = self.D / self.T_total # Кадр данных моделирования self.sim = pd.DataFrame({'time': np.array(range(1, self.T_total+1))})
Начнем с инициализации входных параметров для функций:
- order(), который представляет собой политику периодического заказа (вы заказываете Q единиц каждые T дней)
- моделирование_1(), которое рассчитывает влияние спроса (продаж) и политики заказов на имеющиеся запасы каждый день
class InventorySimulation: ''' [Начало класса] ''' def order(self, t, T, Q, start_day=1): «»»Заказ Q начинается с `start_day`, затем каждые T дней.»»» return Q if (t > start_day and ((t-start_day) % T) == 0) else 0 def simulation_1(self): «»»Заказ с фиксированным циклом; время выполнения заказа НЕ компенсируется.»»» sim_1 = self.sim.copy() sim_1['demand'] = np.random.normal(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) # Инвентаризация: итеративное обновление с учетом времени выполнения заказа ioh = [self.initial_ioh] for t in range(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 для столбца в ['order', 'ioh', 'чек']: sim_1[col] = np.rint(sim_1[col]).astype(int) return sim_1
Функция simulation_1() включает механизм, который обновляет имеющиеся запасы на основе спроса магазина (продаж) и предложения (заказов на пополнение).
Моей целью в этом руководстве было начать с двух основных правил, чтобы объяснить, что происходит, когда вы вводите время опережения, как показано ниже.
В магазинах наблюдается дефицит товаров, как показано на зеленой диаграмме.
Из-за несвоевременных поставок их наличные запасы стали отрицательными.
Что можно сделать? Может быть, увеличить объём заказа Q?
Это то, что я попробовал в уроке; мы обнаружили, что это решение не работает.
Эти два сценария подчеркнули необходимость совершенствования политики заказов , которая компенсирует сроки поставки.
Именно это мы и построили во второй части урока с помощью этих двух дополнительных функций.
class InventorySimulation: ''' [Начало класса] ''' 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, method: Optional[str] = «order_leadtime»): «»»Заказ с фиксированным циклом; время выполнения заказа НЕ компенсируется.»»» sim_1 = self.sim.copy() LD = int(self.LD) sim_1['demand'] = np.maximum(np.random.normal(self.D_day, self.sigma, self.T_total), 0) T = int(self.T) Q = float(self.Q) if method == «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) # Инвентарь: итеративное обновление с учетом времени выполнения заказа ioh = [self.initial_ioh] for t in range(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', 'чек']: sim_1[col] = np.rint(sim_1[col]).astype(int) return sim_1
Идея довольно проста.
На практике это означает, что планировщики запасов должны создавать заказы на пополнение запасов в день = T – LD, чтобы компенсировать время выполнения заказа.
Это гарантирует, что магазины получат свои товары в день = T, как показано в таблице выше.
В конце этого урока у нас будет полноценный инструмент моделирования, позволяющий вам протестировать любой сценарий, чтобы ознакомиться с правилами управления запасами.
Если вам нужны дополнительные разъяснения, вы можете найти подробные объяснения в этом пошаговом руководстве на YouTube:
Однако результатом я остался недоволен.
Зачем нам нужно упаковывать это в веб-приложение?
Продуктивное использование этого инструмента моделирования
Как вы можете видеть на видео, я вручную изменил параметры в блокноте Jupyter, чтобы протестировать различные сценарии.
Это вполне нормально для таких специалистов по работе с данными, как мы.
Но можете ли вы представить себе, чтобы наш директор по логистике открыл Jupyter Notebook в VS Code, чтобы протестировать различные сценарии?
Нам необходимо вывести этот инструмент на рынок, чтобы любой желающий мог получить к нему доступ без навыков программирования или науки о данных.
Хорошие новости: 70% работы выполнено, поскольку у нас есть основные модули.
В следующем разделе я объясню, как мы можем реализовать это в удобном для пользователя аналитическом продукте.
Создайте свое приложение для моделирования инвентаризации с помощью Streamlit
В этом разделе мы создадим одностраничное приложение Streamlit на основе основного модуля из первого урока.
Вы можете начать с клонирования этого репозитория, содержащего ядро моделирования, включая inventory_models.py и inventory_analysis.py.
Имея этот репозиторий на локальном компьютере, вы можете следовать инструкциям и в итоге получить развернутое приложение, подобное этому:
Давайте начнем!
Настройка проекта
Первым шагом является создание локальной среды Python для проекта.
Для этого советую использовать менеджер пакетов uv:
# Создать виртуальную среду и активировать ее uv init uv venv source .venv/bin/activate # Установить uv pip install -r requirements.txt
Он установит библиотеки, перечисленные в файле требований:
streamlit>=1.37 pandas>=2.0 numpy>=1.24 matplotlib>=3.7 pydantic>=2.0
Мы включаем Streamlit, Pydantic и библиотеки для обработки данных (numpy, pandas) и для создания визуальных эффектов (matplotlib).
Теперь вы готовы создать свое приложение.
Создайте свою страницу Streamlit
Создайте файл Python и назовите его: app.py
импорт numpy как np импорт matplotlib.pyplot как plt импорт streamlit как st из inventory.inventory_models импорт InventoryParams из inventory.inventory_analysis импорт InventorySimulation seed = 1991 np.random.seed(seed) st.set_page_config(page_title=»Моделирование инвентаризации – Streamlit», layout=»wide»)
В этом файле мы начинаем с:
- Импорт установленных библиотек и модуля анализа с его классом Pydantic для входных параметров
- Определение начального значения для генерации случайного распределения, которое будет использоваться для генерации переменного спроса
Затем приступаем к созданию страницы с помощью st.set_page_config(), в которую в качестве параметров включаем:
- page_title: заголовок веб-страницы вашего приложения
- макет: возможность задать макет страницы
Установив параметр layout на «wide», мы гарантируем, что страница будет широкой по умолчанию.
Вы можете запустить свое приложение сейчас,
streamlit запустить app.py
После выполнения этой команды ваше приложение можно открыть, используя локальный URL-адрес, указанный в вашем терминале:
После загрузки у вас будет вот такая пустая страница:
Поздравляем, вы запустили свое приложение!
Если на этом этапе у вас возникли проблемы, проверьте следующее:
- Локальная среда Python настроена правильно.
- Вы установили все библиотеки из файла требований.
Теперь мы можем приступить к созданию нашего приложения для управления запасами .
Боковая панель с параметрами управления запасами
Помните класс Pydantic, который мы определили в inventory_models.py?
Они будут служить входными параметрами для приложения, и мы отобразим их на боковой панели Streamlit.
с st.sidebar: st.markdown(«**Параметры запасов**») D = st.number_input(«Годовой спрос D (ед./год)», min_value=1, value=2000, step=50) T_total = st.number_input(«Горизонт T_total (дней)», min_value=1, value=365, step=1) LD = st.number_input(«Срок выполнения заказа LD (дней)», min_value=0, value=0, step=1) T = st.number_input(«Время цикла T (дней)», min_value=1, value=10, step=1) Q = st.number_input(«Объем заказа Q (ед.)», min_value=0.0, value=55.0, step=10.0, format=»%.2f») initial_ioh = st.number_input(«Начальный запас на рука», min_value=0.0, value=55.0, step=1.0, format=»%.2f») sigma = st.number_input(«Стандартное отклонение суточного спроса σ (ед./день)», min_value=0.0, value=0.0, step=0.5, format=»%.2f») метод = st.radio( «Способ заказа», options=[«Простой заказ», «Заказ по времени выполнения заказа»], index=0 ) method_key = «order_leadtime» if method.startswith(«Время выполнения заказа») else «order» запуск = st.button(«Запустить моделирование», type=»primary») if запуск: st.session_state.has_run = True
В эту боковую панель мы включаем:
- Заголовок с использованием st.markdown()
- Поля ввода чисел для всех параметров с их минимальными, стандартными и пошаговыми значениями.
- Переключатель для выбора способа заказа (с учетом или без учета времени выполнения)
- Кнопка для запуска первой симуляции
Перед этим блоком следует добавить переменную состояния сеанса:
если «has_run» не в st.session_state: st.session_state.has_run = False
Это логическое значение указывает, нажал ли пользователь уже кнопку симуляции.
Если это так, приложение будет автоматически перезапускать все расчеты всякий раз, когда пользователь изменяет параметр.
Отлично, теперь ваш app.py должен выглядеть так:
import numpy as np import matplotlib.pyplot as plt import streamlit as st from inventory.inventory_models import InventoryParams from inventory.inventory_analysis import InventorySimulation seed = 1991 np.random.seed(seed) st.set_page_config(page_title=»Моделирование инвентаризации – Streamlit», layout=»wide») if «has_run» not in st.session_state: st.session_state.has_run = False with st.sidebar: st.markdown(«**Параметры инвентаризации**») D = st.number_input(«Годовой спрос D (ед./год)», min_value=1, value=2000, step=50) T_total = st.number_input(«Горизонт T_total (дней)», min_value=1, value=365, step=1) LD = st.number_input(«Срок выполнения заказа LD (дней)», min_value=0, value=0, step=1) T = st.number_input(«Время цикла T (дней)», min_value=1, value=10, step=1) Q = st.number_input(«Объем заказа Q (ед.)», min_value=0.0, value=55.0, step=10.0, format=»%.2f») initial_ioh = st.number_input(«Начальный запас», min_value=0.0, value=55.0, step=1.0, format=»%.2f») sigma = st.number_input(«Стандартное отклонение ежедневного спроса σ (ед./день)», min_value=0.0, value=0.0, step=0.5, format=»%.2f») method = st.radio( «Способ оформления заказа», options=[«Простой заказ», «Заказ по времени выполнения»], index=0 ) method_key = «order_leadtime» if method.startswith(«Время выполнения») else «order» run = st.button(«Запустить моделирование», type=»primary») if run: st.session_state.has_run = True
Вы можете взглянуть на свое приложение, обычно после обновления окно должно выглядеть так:
Слева находится боковая панель, которую мы только что создали.
Затем, для эстетики и удобства пользователя, я хочу добавить заголовок и напоминание об используемых параметрах.
Почему я хочу напомнить используемые параметры?
В левом верхнем углу окна находится кнопка, позволяющая скрыть боковую панель, как показано ниже.
Это дает пользователям больше места для показа визуального образа.
Однако входные параметры будут скрыты.
Поэтому нам нужно добавить напоминание вверху.
st.title(«Веб-приложение для моделирования инвентаризации») # Выбранные входные параметры D_day = D / T_total st.markdown(«»»
«»», unsafe_allow_html=True) def quick_card(label, value, unit=»»): unit_html = f'
{unit}
' if unit else «» st.markdown(f'
{label}
{value}
{unit_html}
', unsafe_allow_html=True)
В приведенном выше фрагменте кода я ввел:
- CSS-стили, встроенные в Streamlit, для создания карточек
- Функция quick_card создаст карточку для каждого параметра, используя его метку, значение и единицы измерения.
Затем мы можем сгенерировать эти карточки в одном ряду, используя объект streamlit st.columns().
c1, c2, c3, c4, c5, c6 = st.columns(6) с c1: quick_card(«Средний дневной спрос», f»{D_day:,.2f}», «единиц/день») с c2: quick_card(«Срок выполнения заказа», f»{LD}», «дней») с c3: quick_card(«Время цикла», f»{T}», «дней») с c4: quick_card(«Объем заказа Q», f»{Q:,.0f}», «единиц») с c5: quick_card(«Начальный IOH», f»{initial_ioh:,.0f}», «единиц») с c6: quick_card(«Спрос σ», f»{sigma:.2f}», «единиц/день»)
Первая строка определяет шесть столбцов, в которых мы размещаем карточки с помощью функции quick_card.
Теперь перейдем к самой интересной части: интеграции инструмента моделирования в приложение.
Возникли вопросы или затруднения на этом этапе? Оставляйте комментарии под видео — постараюсь ответить как можно быстрее.
Интеграция модуля моделирования инвентаризации в приложение Streamlit
Теперь мы можем начать работу над главной страницей.
Представим, что наш директор по логистике заходит на страницу, выбирает различные параметры и нажимает «Запустить симуляцию» .
Это должно запустить модуль моделирования:
если st.session_state.has_run: параметры = параметры инвентаризации (D=число с плавающей точкой (D), T_total=целое число (T_total), LD=целое число (LD), T=целое число (T), Q=число с плавающей точкой (Q), начальный_ioh=число с плавающей точкой (начальный_ioh), сигма=число с плавающей точкой (сигма)) sim_engine = моделирование инвентаризации (параметры)
В этом коротком фрагменте кода мы делаем много вещей:
- Мы создаем объект входного параметра, используя класс Pydantic из inventory_models.py
Это гарантирует, что каждое значение (спрос, время выполнения заказа, период обзора, сигма…) имеет правильный тип данных перед запуском моделирования. - Мы создаем класс движка симуляции InventorySimulation из inventory_analysis.py
Этот класс содержит всю логику инвентаризации, которую я разработал в первом уроке.
В пользовательском интерфейсе ничего не изменится.
Теперь мы можем приступить к определению вычислительной части.
if st.session_state.has_run: ''' [Предыдущий блок, представленный выше]''' if method_key == «order_leadtime»: df = sim_engine.simulation_2(method=»order_leadtime») elif method_key == «order»: df = sim_engine.simulation_2(method=»order») else: df = sim_engine.simulation_1() # Рассчитать ключевые параметры, которые будут показаны под визуальным stockouts = (df[«ioh»] < 0).sum() min_ioh = df["ioh"].min() avg_ioh = df["ioh"].mean()
Сначала мы выбираем правильный способ заказа.
В зависимости от правила упорядочивания, выбранного в переключателе боковой панели, мы вызываем соответствующий метод моделирования:
- method=»order» : это первоначальный метод, который я вам показал, но который не смог поддерживать стабильный запас, когда я добавил время выполнения заказа
- method=»order_leadtime» : это улучшенный метод, который заказывает в день = T – LD
Результаты, хранящиеся в фреймворке данных Pandas (df), используются для вычисления ключевых показателей, таких как количество дефицитов , а также минимальный и максимальный уровни запасов .
Теперь, когда у нас есть результаты моделирования, давайте создадим визуальные эффекты.
Создание визуальных эффектов моделирования инвентаризации на Streamlit
Если вы посмотрели видеоверсию этого урока, то, вероятно, заметили, что я скопировал и вставил код из блокнота, созданного в первом уроке.
if st.session_state.has_run: '''[Предыдущие блоки, представленные выше]''' # Построить график fig, axes = plt.subplots(3, 1, figsize=(9, 4), sharex=True) # ↓ от (12, 8) до (9, 5) # Спрос df.plot(x='time', y='demand', ax=axes[0], color='r', legend=False, grid=True) axes[0].set_ylabel(«Demand», fontsize=8) # Заказы df.plot.scatter(x='time', y='order', ax=axes[1], color='b') axes[1].set_ylabel(«Orders», fontsize=8); axes[1].grid(True) # IOH df.plot(x='time', y='ioh', ax=axes[2], color='g', legend=False, grid=True) axes[2].set_ylabel(«IOH», fontsize=8); axes[2].set_xlabel(«Time (day)», fontsize=8) # Стандартное форматирование x axes[2].set_xlim(0, int(df[«time»].max())) для ax в axes: ax.tick_params(axis='x', rotate=90, labelsize=6) ax.tick_params(axis='y', labelsize=6) plt.tight_layout()
Действительно, тот же визуальный код, который вы используете для создания прототипа в своих блокнотах, будет работать и в вашем приложении.
Единственное отличие состоит в том, что вместо использования plt.show() вы завершаете раздел следующим образом:
st.pyplot(fig, clear_figure=True, use_container_width=True)
Streamlit необходимо явно контролировать рендеринг с помощью
- fig — это рисунок Matplotlib, созданный вами ранее.
- clear_figure=True — параметр для очистки фигуры из памяти после рендеринга, чтобы избежать дублирования графиков при обновлении параметров.
- use_container_width=True , чтобы диаграмма автоматически изменяла размер в соответствии с шириной страницы Streamlit.
На этом этапе в вашем приложении обычно есть следующее:
Если вы попытаетесь изменить какой-либо параметр, например, изменить способ упорядочивания, вы увидите автоматическое обновление изображения.
Что осталось?
В качестве бонуса я добавил раздел, который поможет вам открыть для себя дополнительные функции Streamlit.
if st.session_state.has_run: '''[Предыдущие блоки, представленные выше]''' # Ключевые параметры, представленные ниже визуального представления kpi_cols = st.columns(3) kpi_cols[0].metric(«Дней отсутствия запасов», f»{stockouts}») kpi_cols[1].metric(«Мин. IOH (ед.)», f»{min_ioh:,.0f}») kpi_cols[2].metric(«Средн. IOH (ед.)», f»{avg_ioh:,.0f}») # Информационное сообщение st.success(«Моделирование завершено.»)
В дополнение к столбцам, которые мы уже определили в предыдущем разделе, у нас есть:
- metric(), который генерирует чистую и встроенную карту Streamlit
В отличие от моей пользовательской открытки, здесь вам не понадобится CSS. - st.success() для отображения зеленого баннера успешного выполнения, уведомляющего пользователя об обновлении результатов.
Это та самая вишенка на торте, которая нам была нужна для завершения этого приложения.
Теперь у вас есть полноценное приложение, которое автоматически генерирует визуальные эффекты и легко тестирует сценарии, работая на вашем компьютере.
А как наш директор по логистике может этим воспользоваться?
Позвольте мне показать вам, как легко и бесплатно развернуть его в Streamlit Community Cloud .
Разверните свое приложение в сообществе Streamlit
Сначала вам нужно загрузить свой код на GitHub, как я это сделал здесь: Репозиторий GitHub.
Затем перейдите в правый верхний угол приложения и нажмите «Развернуть».
Затем нажмите «Развернуть сейчас» и следуйте инструкциям, чтобы предоставить доступ к вашей учетной записи GitHub (Streamlit автоматически определит, что вы отправили свой код на GitHub).
Вы можете создать собственный URL-адрес: мой — supplyscience.
После нажатия кнопки «Развернуть» Streamlit перенаправит вас к развернутому приложению!
Поздравляем, вы развернули свое первое приложение Supply Chain Analytics Streamlit!
Есть вопросы? Ознакомьтесь с полным руководством.
Не стесняйтесь задавать вопросы в комментариях или делиться тем, что вы развернули на Streamlit.
Заключение
Я разработал это руководство для версии себя 2018 года.
Тогда я достаточно хорошо знал Python и аналитику, чтобы создавать инструменты оптимизации и моделирования для своих коллег, но я еще не знал, как превратить их в реальные продукты.
Это руководство — первый шаг на пути к индустриализации аналитических решений.
То, что вы создали, возможно, еще не готово к использованию, но это функциональное приложение, которым вы можете поделиться с нашим директором по логистике.
Вам нужно вдохновение для других применений?
Как заполнить это приложение?
Теперь, когда у вас есть руководство по развертыванию приложений Supply Chain Analytics, вы, вероятно, захотите улучшить приложение, добавив больше моделей.
У меня есть для вас предложение.
Вы можете следовать этому пошаговому руководству, чтобы реализовать сегментацию продукта с помощью анализа Парето и диаграммы ABC.
Вы узнаете, как использовать стратегические визуальные инструменты, такие как ABC XYZ, которые помогают розничным компаниям управлять своими запасами.
Это можно легко реализовать на второй странице только что развернутого вами приложения.
При необходимости я могу поработать над еще одной статьей, посвященной этому решению!
Устали от управления запасами?
В этой шпаргалке вы найдете более 80 тематических исследований продуктов ИИ и аналитики для поддержки оптимизации цепочки поставок, прибыльности бизнеса и автоматизации процессов.
Для большинства тематических исследований, опубликованных в журнале Towards Data Science, вы можете найти исходный код, который можно реализовать в приложении Streamlit.
Обо мне
Давайте общаться в Linkedin и Twitter. Я инженер по цепочке поставок, использующий аналитику данных для оптимизации логистических операций и снижения затрат.
Если вам нужна консультация или совет по аналитике и устойчивой трансформации цепочки поставок, свяжитесь со мной через Logigreen Consulting.
Если вас интересуют аналитика данных и цепочка поставок, посетите мой сайт.
Самир Сачи | Наука о данных и производительность
Источник: towardsdatascience.com
