The Effectiveness of AI and ML on Supply Chains Amidst a Global Pandemic

Introduction and Motivation The onset of Covid-19 has not only impacted the world’s most prominent factories in China but also massively disrupted the entire global supply chain. The Covid-19 pandemic has created a severe testing situation for data scientists and analytics to suitably apply AI / ML / Data science to help in the cross response. This would not only entail early diagnosis (drug discovery and development), but also a prediction of old and new drugs and treatments that might alleviate the disease. Furthermore, not only pharmaceutical companies but other industries see a huge benefit in their supply chain in terms of planning, forecasts, cost savings, and increased automation. Companies are becoming extra vigilant in this crisis and shifting their attention to ensure supply chain and value networks are functioning properly. The role of AI/ML and data science has been tremendous to minimize the Covid and to help the supply chain industry. uncertainties To focus on workforce / labor planning Remain cautious / alert on tier-1 supplier risk Manage and utilize the extended supply stock Understand and activate alternate sources of supply Update inventory policy and planning parameters Enhance inbound materials visibility Prepare for plant closures Focus on production scheduling agility Evaluation of alternative outbound logistics options and secure capacity Conduct global scenario planning Covid Impact on SupplyChain The below figure depicts data analysis as modeled by , representing how COVID-19 is affecting a customer’s supply at impacted sites. Blue Yonder Source The objective of this solution is to take feeds from the Center for Disease Control and Prevention (CDC) in real-time and mapping manufacturing and logistics sites to model responses. This helps to achieve accurate predicted arrival times of supplies, helping customers to gain time to resolution to proactively identify issues deep in the supply chain. In addition, customers can also leverage ML-based recommendations to find alternate sources of supply and integrated execution capabilities to turn recommendations into alternate supply shipments. Overall, the goal of introducing AI / ML into the supply chain process is to ease procurement processes, delivery logistics, traceability, or storage, thereby smoothing the accessibility, availability, and quality of medicines. The pharmaceutical companies see a remarkable leap in terms of: – To accurately predict shifts in demand and consumption, decreasing stockouts and wastage. Demand Forecasting – To report substandard medicines in a timely manner. Reporting Substandard medicines – To ensure a continuous supply and provide emergency humanitarian relief to those who are affected and in serious condition. Ensuring Continuous Supply A global disruptive event like Covid-19 has created an awareness among many companies to invest today in a resilient supply chain that will be best positioned to weather the next event that obstructs the global flow of goods In this blog, we list some of the common open-source Supply Chain libraries and address what kind of problems they solve. List of Open Source Supply Chain Libraries Tensor-House TensorHouse is a collection of reference machine learning and optimization models for enterprise operations: marketing, pricing, supply chain, etc that can be used for academic, industrial purposes, and research study. The policy map can be trained using : , trainer = wsrt.train_ppo(n_iterations = 5) where world_of_supply contains internal library implementations which we can define ‘global training policy’ of the trainer for multi-agent reinforcement learning. world_of_supply_rllib_models wsm importlib.reload(wsm) world_of_supply_rllib wsrl importlib.reload(wsrl) world_of_supply_rllib_training wsrt importlib.reload(wsrt) wsrt.print_model_summaries() trainer = wsrt.train_ppo(n_iterations = ) --------------------------------------------------------------------------------------------- ray.rllib.models.modelv2 ModelV2 ray.rllib.models.tf.recurrent_tf_modelv2 RecurrentTFModelV2 ray.rllib.utils.annotations override ray.rllib.utils try_import_tf policy_map = policy_mapping_global.copy() ext_conf = ppo.DEFAULT_CONFIG.copy() ext_conf.update({ : , : , : , : , : , : , : { : filter_keys(policies, set(policy_mapping_global.values())), : create_policy_mapping_fn(policy_map), : [ , ] } }) print( ) ppo_trainer = ppo.PPOTrainer( env = wsr.WorldOfSupplyEnv, config = dict(ext_conf, **base_trainer_config)) training_start_time = time.process_time() i range(n_iterations): print( ) update_policy_map(policy_map, i, n_iterations) print( ) ppo_trainer.workers.foreach_worker( ev: ev.foreach_env( env: env.set_iteration(i, n_iterations))) t = time.process_time() result = ppo_trainer.train() print( ) print_training_results(result) print( ) ppo_trainer import as import as import as # Policy training 5 from import from import from import from import : def train_ppo (n_iterations) "num_workers" 16 "num_gpus" 1 "vf_share_layers" True "vf_loss_coeff" 20.00 "vf_clip_param" 200.0 "lr" 2e-4 "multiagent" "policies" "policy_mapping_fn" "policies_to_train" 'ppo_producer' 'ppo_consumer' f"Environment: action space producer , action space consumer , observation space " {env.action_space_producer} {env.action_space_consumer} {env.observation_space} for in f"\n== Iteration ==" {i} f"- policy map: " {policy_map} lambda lambda f"Iteration took [ ] seconds" {i} {(time.process_time() - t): f} .2 f"Training ETA: [ ] hours to go" {(time.process_time() - training_start_time)*(n_iterations/(i+ ) )/ / : f} 1 -1 60 60 .2 return It yields the following output: - date: _15 - episode_len_mean: - episodes_total: - episode_reward_max: - episode_reward_mean: - episode_reward_min: - timesteps_total: - policy_reward_max: { : , : , : , : } - policy_reward_mean: { : , : , : , : } - policy_reward_min: { : , : , : , : } Training ETA: [ ] hours to go 2021 -01 -03 -13 -43 50.0 2600 218469.5520000001 -110872.94516923078 -360037.5999999991 130000 'baseline_producer' 13610.063999999991 'ppo_producer' 11440.663999999992 'baseline_consumer' 13610.063999999991 'ppo_consumer' 11440.663999999992 'baseline_producer' -4887.064453846157 'ppo_producer' -8704.695287179491 'baseline_consumer' -4887.064453846157 'ppo_consumer' -8704.695287179491 'baseline_producer' -18567.200000000004 'ppo_producer' -26316.4 'baseline_consumer' -18567.200000000004 'ppo_consumer' -26316.4 0.00 Tensor-house also provides optimization techniques to define a (s, Q) -policy as a baseline to order Economic Order Quantity Q, every time an inventory position drops below s. Below is the code snippet demonstrating it, using Facebook’s Ax. ax optimize policy = SQPolicy( p[ ], p[ ], [ p[ ], p[ ], p[ ], ], [ p[ ], p[ ], p[ ], ] ) np.mean(simulate(env, policy, num_episodes = )) best_parameters, best_values, experiment, model = optimize( parameters=[ { : , : , : [ , ], }, { : , : , : [ , ], }, { : , : , : [ , ], }, { : , : , : [ , ], }, { : , : , : [ , ], }, { : , : , : [ , ], }, { : , : , : [ , ], }, { : , : , : [ , ], }, ], evaluation_function=func, minimize= , total_trials= , ) from import : def func (p) 'factory_s' 'factory_Q' 'w1_s' 'w2_s' 'w3_s' 'w1_Q' 'w2_Q' 'w3_Q' return 30 "name" "factory_s" "type" "range" "bounds" 0.0 30.0 "name" "factory_Q" "type" "range" "bounds" 0.0 30.0 "name" "w1_s" "type" "range" "bounds" 0.0 20.0 "name" "w1_Q" "type" "range" "bounds" 0.0 20.0 "name" "w2_s" "type" "range" "bounds" 0.0 20.0 "name" "w2_Q" "type" "range" "bounds" 0.0 20.0 "name" "w3_s" "type" "range" "bounds" 0.0 20.0 "name" "w3_Q" "type" "range" "bounds" 0.0 20.0 False 200 in-toto in-toto is built as a framework to protect the integrity of the software supply chain, by validating each step through authorized personnel ensuring the product does not tamper in transit. Neural Combinatorial Optimization with RL This library implementation using Tensorflow 1.15 uses Neural Network consists in an RNN or self-attentive encoder-decoder with an attention module connecting the decoder to the encoder where the model is trained by Policy Gradient. This kind of neural combinatorial optimization framework can be used to solve the traveling salesman problem (TSP) to optimize tour lengths in a permutation of cities. This kind of library finds great application in optimizing distances between warehouses, distribution centers, and retail store locations. The following code demonstrates how to train and visualize a 2D TSP problem from scratch. python main.py --max_length= --inference_mode= --restore_model= --save_to= /model --log_dir=summary/ /repo tensorboard --logdir=summary/ /repo python main.py --max_length= --inference_mode= --restore_model= --restore_from= /model 20 False False 20 20 20 20 True True 20 Multi-echelon-inventory-optimization This library builds a simulation-optimization framework that minimizes average inventory while maintaining desired average β service level at stocking location. The framework creates an inventory profile (along with associated inventory parameters such as on-hand, inventory position, service level, etc.) across time, which considers a base stock policy with a reorder point. If inventory position <= ROP, an order of the amount (base stock level – current inventory level) is placed by the facility. The below code demonstrates how to evaluate the objective function for optimization to minimize on-hand inventory and heavily penalize not meeting the beta service level (demand volume based). Initially, the set of supply change nodes (configurable) needs to be initialized. base_stock_guess = initial_guess[:(numNodes - )] ROP_guess = initial_guess[(numNodes - ):] baseStock = np.insert(base_stock_guess, , ) ROP = np.insert(ROP_guess, , ) initialInv = *baseStock replications = totServiceLevel = np.zeros(numNodes) totAvgOnHand = i range(replications): nodes = simulate_network(i,numNodes,nodeNetwork,initialInv,ROP,baseStock, demandAllNodes,defaultLeadTime,leadTimeDelay) totServiceLevel = np.array([totServiceLevel[j] + nodes[j].serviceLevel j range(len(nodes))]) totAvgOnHand += np.sum([nodes[j].avgOnHand j range(len(nodes))]) servLevelPenalty = np.maximum( , serviceTarget - totServiceLevel/replications) objFunValue = totAvgOnHand/replications + *np.sum(servLevelPenalty) # Split the initial guess to get base stock and ROP 1 1 # Insert the supply node's base stock 0 10000 # Insert a zero ROP for the first source node 0 0 # Initialize inventory level 0.9 20 0.0 for in for in for in 0 # element-wise max 1.0e6 The below figure illustrates a typical supply value chain network that the given framework optimizes. Source DeepBeerInventory-RL This library – A Deep Q-Network for the Beer Game – Deep Reinforcement Learning for Inventory Optimization optimizes the Inventory Costs such that the Individual Supply Chain Cost and Total Supply Chain Cost is reduced as much as possible. During the optimization, it tries to avoid Out of Stock option and maintain supply chain equilibrium. The following figure illustrates a typical facility unit (distributor) with its incoming and outgoing streams/channels. Source Training a srdqn Warehouse the initial inventory of units which plays Sterman co-players, to run the training episodes: python main.py --gameConfig= --maxEpisodesTrain= config.ILInit2= --batchSize= beerGame = clBeerGame(config) demand_len = np.shape(demandTr)[ ] beerGame.doTestMid(demandTs[ :config.testRepeatMid]) i range( , config.maxEpisodesTrain): beerGame.playGame(demandTr[i%demand_len], ) (np.mod(beerGame.curGame,config.testInterval) == ) (beerGame.curGame> ): beerGame.doTestMid(demandTs[ :config.testRepeatMid]) beerGame.doTestMid(demandTs[ :config.testRepeatMid]) with 10 with and for 50000 8 50000 10 128 #Internally the beergame is intialized as follows: # initilize an instance of Beergame # get the length of the demand. 0 # Do Initial tests 0 # train the specified number of games for in 0 "train" # get the test results if 0 and 500 0 # do the last test on the middle test data set. 0 TensorFlow Object Detection The below video illustrates how we can leverage ML to facilitate sorting packages into different categories according to their final destination. It uses Tensorflow Object Detection API to train a deep learning model based on Architecture. Faster RCNN When a camera is placed above the conveyor belt, it can send a snapshot of the parcel to the computer, which can be processed and ran through a Deep Learning algorithm (Faster RCNN) on the image, to automatically sort and determine the appropriate destination for the package. . Watch this Youtube link https://youtu.be/uextIyx7sO4 SunFlow This library primarily provides a tool to design and optimize all kinds of industrial supply chains from simple transportation networks up to complex multi-level manufacturing setups comprising of components, parts, products, substitutes, suppliers, manufacturers, distributors and customers. Network Design This library solves some of the critical Decision Optimization business problems for the Network Design phase like the Facility Location Problem (FLP). It becomes necessary for many retailers to decide where to open a new warehouse to optimize supply chain cost between plants or providers and customers or chops, or for a water distribution company to plan improvement of the distribution network, creating new tanks or new pipes. The below code snippet demonstrates how to optimize network design with the KPI (Key Performance Indicator) for each of the costs: variable plant cost inbound transportation cost (from plant to distribution center) outbound transportation cost (from distribution center to customer) fixed distribution centers cost variable distribution center cost A number of newly opened distribution centers For this below code snippet, we also applied different constraints as mentioned below: capacity constraints: one on the plants and products --- one on the plants and products and distribution centers demand satisfaction: what is shipped to a customer is exactly the quantity they expect flow on distribution centers structural constraint: what goes in from plants goes out to customers. cost variables definition constraints docplex.mp.model Model mdl = Model(name= ); openDC = mdl.binary_var_dict(distributionCenters, name= ) shipDCToCustomer = mdl.continuous_var_cube(distributionCenters, products, customers, lb= , name= ) shipPlantToDC = mdl.continuous_var_cube(plants, products, distributionCenters, lb= , name= ) shipDCCost = mdl.continuous_var_dict(distributionCenters, lb= , name= ) storeDCCost = mdl.continuous_var_dict(distributionCenters, lb= , name= ) mdl.print_information() variablePlantCost = mdl.sum( df_productionData.varPlantCost[pl, pr] * shipPlantToDC[pl, pr, dc] pl plants pr products dc distributionCenters) mdl.add_kpi(variablePlantCost, ) inboundTransportationCost = mdl.sum( df_inboundData.unitCost[pl, dc]*shipPlantToDC[pl, pr, dc] pl plants pr products dc distributionCenters) mdl.add_kpi(inboundTransportationCost, ) outboundTransportationCost = mdl.sum( shipDCCost[dc] dc distributionCenters) mdl.add_kpi(outboundTransportationCost, ) fixedDistributionCenterCost = mdl.sum( df_distributionCenters.fixedCost[d] * openDC[d] d distributionCenters); mdl.add_kpi(fixedDistributionCenterCost, ); variableDistributionCenterCost = mdl.sum ( storeDCCost[dc] dc distributionCenters) mdl.add_kpi(variableDistributionCenterCost, ); nbOpenDistributionCenters = mdl.sum( openDC[dc] dc distributionCenters) mdl.add_kpi(nbOpenDistributionCenters, ) mdl.print_information() mdl.minimize( variablePlantCost + inboundTransportationCost + outboundTransportationCost + variableDistributionCenterCost + fixedDistributionCenterCost ) mdl.print_information() # CREATE CPLEX MODEL from import 'NetworkDesign' # CREATE VARIABLES 'openDC' 0 'shipDCToCustomer' 0 'shipPlantToDC' 0 'shipDCCost' 0 'storeDCCost' # CREATE KPIS for in for in for in 'variablePlantCost' for in for in for in 'inboundTransportationCost' for in 'outboundTransportationCost' for in 'fixedDistributionCenterCost' for in 'variableDistributionCenterCost' for in 'nbOpenDistributionCenters' # CREATE OBJECTIVE Source Consolidating the from the previous steps: outputs Model: NetworkDesign - number of variables: - binary= , integer= , continuous= - number of constraints: - linear= - parameters: defaults - problem type : MILP Total (root+branch&cut) = sec. ( ticks) * model NetworkDesign solved objective = * KPI: variablePlantCost = * KPI: inboundTransportationCost = * KPI: outboundTransportationCost = * KPI: fixedDistributionCenterCost = * KPI: variableDistributionCenterCost = * KPI: nbOpenDistributionCenters = 980 28 0 952 0 0 is 0.35 125.19 with 3195083.710 1024800.000 0.000 1499483.710 500000.000 170800.000 1.000 Supplychainpy It is a python library for supply chain analysis, modeling, and simulation, with facilities to create workflows for Demand Planners, Buyers, Supply Chain Analysts, and BI Analysts. It helps them with Visualisation tools, allowing them to build reports and perform demand forecasts. The following code snippet can be used to depict supply chain orders with parameters (safety stock, total_orders, quantity_on_hand, economic_order_quantity, demand_variability, reorder_level, average_orders, safety_stock and orders, etc.) supplychainpy.model_inventory analyse supplychainpy.sample_data.config ABS_FILE_PATH decimal Decimal pandas pd raw_df = pd.read_csv(ABS_FILE_PATH[ ]) analyse_kv = dict(df=raw_df,start= , interval_length= , interval_type= , z_value=Decimal( ), reorder_cost=Decimal( ), retail_price=Decimal( ), file_type= , currency= ) analysis_df = analyse(**analyse_kv) from import from import from import import as 'COMPLETE_CSV_SM' 1 12 'months' 1.28 400 455 'csv' 'USD' Predicted output: { : , : { : ( , , , , , , , , , , , )}, : , : , : , : , : , : , : , : , : , : , : , : , : , : , : , : } ... 'reorder_level' '4069' 'orders' 'demand' '1509' '1855' '2665' '1841' '1231' '2598' '1988' '1988' '2927' '2707' '731' '2598' 'total_orders' '24638' 'economic_order_quantity' '44' 'sku' 'KR202-209' 'unit_cost' '1001' 'revenue' '123190000' 'quantity_on_hand' '1003' 'shortages' '5969' 'excess_stock' '0' 'average_orders' '2053.1667' 'standard_deviation' '644' 'reorder_quantity' '13' 'safety_stock' '1165' 'demand_variability' '0.314' 'ABC_XYZ_Classification' 'BY' 'economic_order_variable_cost' '15708.41' 'currency' 'USD' Further, for demand forecasting problems we can also apply different types of forecasting like Exponential Smoothing ses_df = simple_exponential_smoothing_forecast(demand=KR202_209_details[ ].get( ).get( ), length= , smoothing_level_constant= ) 0 'orders' 'demand' 12 0.5 ot-node This javascript library (OriginTrail) is dedicated to making global supply chains work together, by enabling a universal, collaborative, and trusted data exchange. Further, itis built as an open protocol for cross-organizational data sharing in supply chains, supported by blockchain. HIRS This library is equipped with Attestation Certificate Authority (ACA) and TPM Provisioning with Trusted Computing for Supply Chain Validation capabilities. blockchain-supply-chain This repository develops a technical framework for improving traceability in supply chain systems using blockchain. Hyperledger Composer Supply Chain Network The implemented in this repository can be used for the supply-chain industry. This library demonstrates how Hyperledger blockchain improves transparency and traceability of the industrial supply chain. Hyperledger Composer blockchain-supply-chain-solution This library acts a “umbrella” repository for blockchain supply-chain solutions, with support for archiving, retrieval, and validations of attachments. The in-built core-services provided has API support to interact with the . Ethereum smart contract BlockChain_Supply_Chain This library deals with pharmaceutical Supply Chain logistics to help in medicine delivery. It has functionalities to provide accurate information across the entire supply chain pipeline and through real-time updates and visibility of handovers. It also provides traceability of sources and collaboration between all parties at an enhanced speed. hlf1.4-supply-chain This Supply chain proof of concept is built in Hyperledger Fabric, with a specific chaincode exposed as a REST API. BlockSCM This library serves the Automobile Supply Chain Management for transparency and auditability, with support for differential pricing, mediation between different parties, quality and compliance issues, inevitable disruptions, centralization, and fraud management acclimate This library provides a dynamic agent-based model acclimate describing the propagation of disaster-induced production losses in the global economic network. supply_chain_mining There are severe limitations in supply chain frameworks that struck companies to maintain complete visibility of their supply network. This library provides automated supply chain mapping as a means of maintaining the structural visibility of a company’s supply chain. Deep Learning and Natural Language Processing can be leveraged to a) automatically generate rudimentary supply chain maps, b) verify existing supply chain maps or c) augment existing maps with additional supplier information. optimization-library This library has a framework, to optimize production planning, using pulp and 4 different solvers: CBC (default), Gurobi, CPLEX, and GLPK. The following code demonstrates how to defining production variables and inventory constraints. Define Production variables: production_variables = { index: pulp.LpVariable(name= + str(row[ ]), lowBound= , cat=pulp.LpContinuous) index, row input_df_dict[ ].iterrows()} OR production_variables = pulp.LpVariable.dicts( name= , indexs=input_df_dict[ ].index, lowBound= , cat=pulp.LpContinuous) 'X_' 'period' 0 for in 'input_data' 'X' 'input_data' 0 Define Inventory Constraints: period, value input_df_dict[ ].iloc[ :].iterrows(): model.addConstraint(pulp.LpConstraint( e=inventory_variables[period - ] + production_variables[period] - inventory_variables[period], sense=pulp.LpConstraintEQ, name= + str(period), rhs=value.demand)) OR inv_balance_constraints = { period: model.addConstraint(pulp.LpConstraint( e=inventory_variables[period - ] + production_variables[period] - inventory_variables[period], sense=pulp.LpConstraintEQ, name= + str(period), rhs=value.demand)) period, value input_df_dict[ ].iloc[ :].iterrows()} for in 'input_data' 1 1 'inv_balance' 1 'inv_balance' for in 'input_data' 1 For more details on their mode of operating and response time, please refer to A Simple Framework For Solving Optimization Problems in Python. Awesome Supply chain This repository contains a curated list of awesome supply chain blogs, podcasts, standards, projects, and examples. Other Supply Chain BlockChain Repositories – A Supply Chain smart contract built-in to demonstrate how supply chains can improve authenticity, efficiency, and privacy between seller and buyer. Ethereum-SupplyChain – A blockchain-based on tender mint, making deployment, multiple networks connection, and run supply chain applications easier. ichain – A blockchain-based Product Ownership Management System for anti-counterfeits in the Post Supply Chain AuthentiFi keras-rl It implements some state-of-the-art deep reinforcement learning algorithms in Keras (Python) and is capable of solving complex optimization problems of the Supply Chain. ray ray tune ray.rllib.policy Policy ray.rllib.examples.env.multi_agent MultiAgentCartPole ray.tune.registry register_env ray.init() register_env( , _: MultiAgentCartPole( )) single_env = gym.make( ) obs_space = single_env.observation_space act_space = single_env.action_space tune.run( , stop={ : args.num_iters}, config={ : , : { : { : ( , obs_space, act_space, {}), : (RandomPolicy, obs_space, act_space, {}), }, : tune.function( agent_id: [ , ][agent_id % ]), }, }, ) import from import from import from import from import # Simple environment with 4 independent cartpole entities "multi_cartpole" lambda 4 "CartPole-v0" "PG" "training_iteration" "env" "multi_cartpole" "multiagent" "policies" "pg_policy" None "random" "policy_mapping_fn" lambda "pg_policy" "random" 2 Conclusion In this blog, we have seen the impact of Covid on the supply-chain industry leading to revenue loss and lot of uncertainties. In order to combat the situation, we must make use of AI / ML frameworks to apply route optimizations, price optimization or inventory optimization, which we demonstrate with different code samples. We also refer to many other open-source libraries available that can be used for making supply chain transactions either using blockchain or for expediting supply chain analytics. Source As the above figure illustrates, along with AI / ML the most important technologies for the efficient functioning of the supply chain are IoT, cloud computing, 5G, AI, 3D printing, and robotics. However, technology alone can’t drive the digital supply network in events like COVID-19, a trade war, an act of war or terrorism, regulatory change, labor dispute, a spike in demand for a particular product in a specific region, or supplier bankruptcy. What is utmost at this moment of crisis is risk management, performance management, and timely proactive measures to ensure overall business continuity. References https://www.mckinsey.com/business-functions/operations/our-insights/covid-19-and-supply-chain-recovery-planning-for-the-future https://www2.deloitte.com/content/dam/Deloitte/ca/Documents/finance/Supply-Chain_POV_EN_FINAL-AODA.pdf https://www.mckinsey.com/~/media/McKinsey/Business%20Functions/Operations/Our%20Insights/COVID%2019%20and%20supply%20chain%20recovery%20Planning%20for%20the%20future/COVID-19-and-supply-chain-recovery-Planning-for-the-future-VF.pdf?shouldIndex=false https://www.imd.org/research-knowledge/articles/supply-chains-adapting-to-covid-19/ https://www2.deloitte.com/global/en/pages/risk/articles/covid-19-managing-supply-chain-risk-and-disruption.html http://www.businessworld.in/article/AI-Robotics-Steering-The-Supply-Chain-Ship-Amidst-COVID-19-Crisis/24-07-2020-300849/ https://www.h2o.ai/resources/executive-brief/supply-chain-and-logistics-considerations-during-and-after-covid-19/ https://www.supplychaindigital.com/technology-4/how-digital-automation-shaping-modern-supply-chains https://www.devex.com/news/opinion-how-ai-can-push-for-equitable-access-to-covid-19-vaccines-98565 https://www2.deloitte.com/content/dam/Deloitte/us/Documents/process-and-operations/us-supplychain-digitalanalytics-survey2019.pdf https://blog.blueyonder.com/mitigating-the-impact-of-the-coronavirus-on-supply-chains-with-machine-learning-and-real-time-visibility/ https://blog.griddynamics.com/multi-agent-deep-reinforcement-learning-multi-echelon-supply-chain-optimization/ https://blog.griddynamics.com/dynamic-pricing-algorithms/ https://www.semanticscholar.org/paper/Multi-echelon-Supply-Chain-Inventory-Planning-using-Agarwal/12ebceba1d30f9ac625b625fd606ee77e94e7e16 https://github.com/IBMDecisionOptimization/do-ws-js https://medium.com/@ehsankhoda/tutorial-a-simple-framework-for-optimization-programming-in-python-using-pulp-and-gurobi-1e73e76532f2 Previously published here .