《现代库存管理：模型、算法与Python实现》 课件 第15、16章 承诺服务模型、某食品企业Z的分销网络库存优化实战

现代库存管理：模型、算法与Python实现第15章承诺服务模型15.1承诺服务模型的需求规划问题

15.1承诺服务模型的需求规划问题

15.2需求上界的构造与计算

15.2需求上界的构造与计算

15.2需求上界的构造与计算例：以下图的生产装配网络为对象，计算给定服务水平为0.95的情况下，每个节点的需求上界#定义数据存储路径

data_dir=

'../../data/tree_example/'

#读取网络的节点数据

node_df=pd.read_csv(data_dir+

'assembly_node_df.csv')

#读取网络的边数据

edge_df=pd.read_csv(data_dir+

'assembly_edge_df.csv')

#读取网络的需求数据

demand_df=pd.read_csv(data_dir+

'assembly_demand_df.csv')15.2需求上界的构造与计算例：数据概况节点信息表’node_df’：’lt’：节点的单级提前期’hc’：单位持货成本’sla’：对客户承诺的服务时间node_idlthcsla0C180.4685565NaN1B111.994935NaN2C270.271441NaN3C330.632656NaN4B280.861130NaN5A33.7657402.0边信息表’edge_df’：’predecessor’：上游节点’successor’：下游节点’quantity’：生产配比predecessorsuccessorquantity0C1B111B1A12C2B123C3B214B2A1需求信息表’demand_df’：只有节点A为需求节点，mean为14.558117，std为2.89212915.2需求上界的构造与计算假设库存共享效应系数为2，服务水平系数取标准正态分布的0.95分位数。相当于假设需求服从正态分布，同时模型仅覆盖0.95分位数以下的需求波动

pooling_factor=

2

tau=

0.9515.2需求上界的构造与计算具体代码如下：#调用第10章确定上游节点的函数得到每个节点的上游节点列表

pred_dict=find_predecessors_dict(edges=edge_df[['predecessor',

'successor']].values)

#生产配比

qty_dict={(pred,succ):qtyforpred,succ,qtyinedge_df.values}

#需求节点的需求及标准差

mu_dict=dict(zip(demand_df['node_id'],demand_df['mean']))

sigma_dict=dict(zip(demand_df['node_id'],demand_df['std']))

#各节点自身需求所对应的需求波动系数

ksigma_dict={node:0

fornodeinnode_df['node_id']}

ksigma_dict.update({node:norm.ppf(tau)*sigma

fornode,sigmainsigma_dict.items()})

#初始化涉及到向下传递的字典

network_mu_dict={node:0

fornodeinnode_df['node_id']}

#首先将需求节点的信息加入到字典中

network_mu_dict.update({node:mufornode,muinmu_dict.items()})

constant_dict={node:v**pooling_factorfornode,vinksigma_dict.items()}15.2需求上界的构造与计算具体代码如下：#将网络的边反向

reverse_edges=[(j,i)fori,jin

edge_df[['predecessor','successor']].values]

#计算拓扑排序

ts=TopologicalSort(reverse_edges)

reverse_topo_sort=ts()

fornodeinreverse_topo_sort:

#如果节点有上游节点，则将自身的需求信息传递给上游节点

iflen(pred_dict[node])>

0:

forpredinpred_dict[node]:

constant_dict[pred]+=(qty_dict[pred,node]**pooling_factor)\

*constant_dict[node]

network_mu_dict[pred]+=qty_dict[pred,node]*network_mu_dict[

node]

#在全部节点传递完成后，计算需求波动系数

volatility_constant_dict={node:np.power(v,1

/pooling_factor)

fornode,vinconstant_dict.items()}

volatility_constant_df=pd.DataFrame.from_dict(

volatility_constant_dict,orient='index').reset_index().rename(

columns={'index':'node_id',0:'volatility_constant'})

network_mu_df=pd.DataFrame.from_dict(

network_mu_dict,orient='index').reset_index().rename(

columns={'index':'node_id',0:'mean'})15.2需求上界的构造与计算具体代码如下：lt_dict=dict(zip(node_df['node_id'],node_df['lt']))

cum_lt_dict=cal_cum_lt(edge_df[['predecessor','successor']].values,lt_dict)

cum_lt_df=pd.DataFrame.from_dict(

cum_lt_dict,orient='index').reset_index().rename(

columns={'index':'node_id',0:'cum_lt'})

node_df=node_df.merge(cum_lt_df,on='node_id',how='left')

print(node_df)#定义离散化的时间颗粒度

time_unit=

1

#根据节点和对应的累计提前期，生成index

node_list=node_df['node_id'].tolist()

idx=[(node,ct)fornodeinnode_list

forctinnp.arange(0,cum_lt_dict[node]+time_unit,time_unit)]

idx=pd.MultiIndex.from_tuples(idx,names=['node_id','time'])

demand_bound_df=pd.DataFrame(index=idx).reset_index()

demand_bound_df=demand_bound_df.merge(

volatility_constant_df,on=['node_id'],how='left')

demand_bound_df=demand_bound_df.merge(

network_mu_df,on=['node_id'],how='left')

#根据对应的CT，计算对应的安全库存量，以及需求上界

demand_bound_df['ss_qty']=demand_bound_df['volatility_constant']*np.power(

demand_bound_df['time'],1

/pooling_factor)

demand_bound_df['demand_bound']=demand_bound_df['mean']*demand_bound_df[

'time']+demand_bound_df['ss_qty']

print(demand_bound_df.head())15.2需求上界的构造与计算结果如下：node_idtimevolatility_constantmeanss_qtydemand_bound0C104.75712914.558170.0000000.0000001C114.75712914.558174.75712919.3152472C124.75712914.558176.72759735.8438323C134.75712914.558178.23959051.9139424C144.75712914.558179.51425867.74672815.2需求上界的构造与计算不同服务时间下的策略及成本比较：

根据计算得到的demand_bound_df，查找出每个节点不同覆盖时间的安全库存量，计算出总库存成本，接下来考虑三种比较有代表性的策略：只在最下游设置安全库存。该策略将安全库存全部前置到需求节点，即只持有成品库存。其好处是将所有节点安全库存的覆盖时间全部汇聚在需求节点，这样可以最大化安全库存在“时间维度”的共享效应。其劣势是完全忽视了安全库存在“空间”维度的共享效应按照单级的方法设置安全库存。该策略下，每个节点都根据自身的提前期按照单级的方式计算安全库存。其好处是计算简单，但它完全没有考虑到网络中安全库存的共享效应，也忽略了节点之间持货成本的差异，没有对安全库存进行全网络优化网络最优的安全库存。该策略通过优化所有节点的服务时间，在保证需求节点的承诺服务时间的条件下，充分挖掘网络中安全库存“空间维度”和“时间维度”的共享效应，最小化网络的总安全库存成本15.2需求上界的构造与计算不同服务时间下的策略及成本比较：只在最下游设置安全库存：前面计算过，节点A的累计提前期为14天，它的承诺服务时间为2天，如果只在节点A上设置安全库存，它的覆盖时间CT=14-2=12天，其他节点的覆盖时间都为0，经计算该策略的安全库存成本为62.06使用单级的方法设置安全库存：在该策略下，需求节点A的覆盖时间等于自身提前期减去其sla，其他节点的覆盖时间都是自身提前期，该策略的安全库存总成本为57.34网络最优的安全库存策略：本章的后续内容将介绍如何优化承诺服务模型。这里先直接给出该网络下每个节点的最优覆盖时间：{’B2’:10,’B1’:0,’C1’:8,’C2’:7,’A’:2,’C3’:0}。根据给出的最优覆盖时间，可以得到最优的安全库存策略及其成本51.43可以看出，相比于前两种方法，最优的安全库存策略能够显著降低库存成本15.3承诺服务模型的优化算法动态规划算法：例：对下图树网络中的节点进行排序步骤2可能出现多种选择，因此得到的排序可能不唯一

得到一组符合要求的排序：[’D1’,’D2’,’C2’,’A1’,’A2’,’C1’,’B’]那么该树网络中每个节点对应的排序标记为：{’A1’:4,’A2’:5,’B’:7,’C1’:6,’C2’:3,’D1’:1,’D2’:2}15.3承诺服务模型的优化算法动态规划算法：

A1B{A1}A2B{A2}B\{A1,A2,C1,C2}C1B{C1,D1,D2}C2B{C2}D1C1{D1}D2C1{D2}15.3承诺服务模型的优化算法动态规划算法：

15.3承诺服务模型的优化算法求解树网络上的最优成本：

15.3承诺服务模型的优化算法求解树网络上的最优成本：

15.3承诺服务模型的优化算法基于分段线性函数近似的混合整数规划算法：

15.3承诺服务模型的优化算法基于分段线性函数近似的混合整数规划算法：

15.3承诺服务模型的优化算法基于分段线性函数近似的混合整数规划算法：安全库存量的分段线性近似结构图：15.3承诺服务模型的优化算法基于分段线性函数近似的混合整数规划算法：基于分段线性近似后的目标函数带入到承诺服务模型中，得到近似后的优化模型：：

现代库存管理：模型、算法与Python实现第16章某食品企业Z的分销网络库存优化实战16.1背景介绍企业Z是一家大型国际食品制造商：公司在中国建成了三级供应网络，有一个工厂，南北两个区域大仓，北方区域大仓下辖三个分销中心，南方区域大仓下辖五个分销中心，由分销中心向各区域的客户进行履约目前公司供应网络的库存管理主要采用单级的策略，每个仓采用覆盖自身提前期的目标库存策略来管理库存企业的发展趋势和转型需求：搭建了一套智慧供应链管理系统，将数据、算法和人工协作有机结合，加强供应网络的全局协同能力旨在研发一套分销网络的全局安全库存优化模型与算法，嵌入到其供应链管理系统当中16.1背景介绍挑选公司旗下的7个核心SKU，以这7个SKU的数据来探究如下两个问题：从全局优化的角度，这7个SKU的安全库存应该分别布局在哪些仓，以及相应的量应该是多少？全局优化后的安全库存策略相比于当前策略，能否显著降低总安全库存成本？研究方法步骤：将Z公司的分销网络建立成一个树网络对网络进行分析并建立相应的承诺服务模型利用动态规划算法求解最优的安全库存策略并分析其价值16.2数据导入及预处理#导入网络分析包

importnetworkxasnx

#导入数据分析包

importnumpyasnp

importpandasaspd

importmatplotlib.pyplotasplt

fromcollectionsimportdefaultdict

#导入第14章介绍过的几个算法

fromchapter14_network_basicimportfind_predecessors_dict,find_successors_dict,\

cal_cum_lt,cal_demand_bound

importwarnings

warnings.filterwarnings('ignore')#定义数据路径

data_dir=

'../../data/food/'

#读取分销网络的边数据

edge_df=pd.read_csv(data_dir+

'edge_data.csv')

#读取各SKU的生产时间数据

production_time_df=pd.read_csv(data_dir+

'production_time_data.csv')

#读取各节点的特征数据

feature_df=pd.read_csv(data_dir+

'feature_data.csv')

#读取需求节点（DC）的需求数据

demand_df=pd.read_csv(data_dir+

'demand_data.csv')16.2数据导入及预处理数据集概况：edge_df表：分销网络的边信息表’predecessor’：上游节点’successor’：下游节点’transport_time’：从上游节点到下游节点所需运输时间’quantity’：配比在分销网络中上下游只是运输传送关系，配比均为1predecessorsuccessortransport_timequantity0F000RDC001311F000RDC002212RDC001DC004113RDC001DC008214RDC001DC010315RDC002DC003116RDC002DC005217RDC002DC007118RDC002DC006319RDC002DC0092116.2数据导入及预处理数据集概况：利用NetworkX，对Z企业的分销网络进行可视化展示：16.2数据导入及预处理数据集概况：production_time_df表：7个SKU的生产时间sku_idproduction_time0SKU00031SKU00132SKU00213SKU00314SKU00425SKU00536SKU006316.2数据导入及预处理数据集概况：feature_df表：各个SKU在各节点（工厂，RDC和DC）的持货成本’hc’：持货成本’sla’：对客户承诺的服务时间’unit_id’：一个节点与一个SKU的组合node_idsku_idhcslaunit_id0DC003SKU0000.841DC003_SKU0001DC004SKU0000.871DC004_SKU0002DC005SKU0000.881DC005_SKU0003DC006SKU0000.884DC006_SKU0004DC007SKU0000.894DC007_SKU00016.2数据导入及预处理数据集概况：demand_df表：从历史销量数据中统计得到的各SKU在各个需求节点（各个DC）的需求均值和标准差node_idsku_idmeanstdunit_id0DC003SKU000108.767138146.382985DC003_SKU0001DC003SKU00191.416757142.366810DC003_SKU0012DC003SKU002129.607221209.291639DC003_SKU0023DC003SKU00397.410929174.465898DC003_SKU0034DC003SKU00492.281828139.159005DC003_SKU00416.2数据导入及预处理数据集预处理：以SKU’SKU000’为例将’SKU000’的相关数据提取出来，并进行预处理，计算出每个节点的累计提前期计算每个节点覆盖时间的需求上界及安全库存量，计算周期服务水平为0.95对应的需求上界将后续要反复使用的数据转换成字典格式数据集预处理代码如下：sku=

'SKU000'

#将sku对应的需求信息提取出来

sku_demand_df=demand_df[demand_df['sku_id']==sku]

#分销网络的配比均为1

qty_dict={(pred,succ):qforpred,succ,qin

edge_df[['predecessor','successor','quantity']].values}

16.2数据导入及预处理数据集预处理代码：#根据sku对应的生产加工时间，计算每个节点的累计提前期

sku_production_time=int(production_time_df[

production_time_df['sku_id']==sku][

'production_time'])

lt_dict=dict(zip(edge_df['successor'],edge_df['transport_time']))

lt_dict.update({'F000':sku_production_time})

lt_df=pd.DataFrame.from_dict(

lt_dict,orient='index').reset_index().rename(

columns={'index':'node_id',0:'lt'})

cum_lt_dict=cal_cum_lt(edge_df[['predecessor','successor']].values,lt_dict)

cum_lt_df=pd.DataFrame.from_dict(

cum_lt_dict,orient='index').reset_index().rename(

columns={'index':'node_id',0:'cum_lt'})

#将sku对应的节点属性表读取出来，并将提前期与累计提前期合并到一张表上，方便分析

sku_node_df=feature_df[feature_df['sku_id']==sku]

sku_node_df=sku_node_df.merge(lt_df,on='node_id',how='left')

sku_node_df=sku_node_df.merge(cum_lt_df,on='node_id',how='left')

print(sku_node_df)16.2数据导入及预处理数据集预处理代码：#累计提前期

cum_lt_dict=dict(zip(sku_node_df['node_id'],sku_node_df['cum_lt']))

#提前期

lt_dict=dict(zip(sku_node_df['node_id'],sku_node_df['lt']))

#每个节点对应覆盖时间的安全库存量

ss_ct_dict={(node,time):ssfornode,time,ssin

sku_demand_bound_df[['node_id','time','ss_qty']].values}

#持货成本

hc_dict=dict(zip(sku_node_df['node_id'],sku_node_df['hc']))

#sla

sla_df=sku_node_df[sku_node_df['sla'].notna()]

sla_dict=dict(zip(sla_df['node_id'],sla_df['sla']))#将sku对应的节点属性表读取出来，并将提前期与累计提前期合并到一张表上，方便分析

sku_node_df=feature_df[feature_df['sku_id']==sku]

sku_node_df=sku_node_df.merge(lt_df,on='node_id',how='left')

sku_node_df=sku_node_df.merge(cum_lt_df,on='node_id',how='left')

print(sku_node_df)16.3应用动态规划算法求解最优策略

16.3应用动态规划算法求解最优策略对网络中的节点进行排序：找到满足除了根节点之外，每个节点至多有一个相邻节点在该节点之后的序列defsort(graph):

#将图转化成无向图

un_di_graph=graph.to_undirected()

#计算图中节点总数

nodes_num=len(un_di_graph.nodes())

sorted_list=[]

#如果还有节点未被加入排序，则继续

whilelen(sorted_list)<nodes_num:

#调用NetworkX计算节点的度数

degree_dict={node:vfornode,vinun_di_graph.degree()}

#将最多只有一个节点与其相邻的节点加入排序

border_nodes=[nodefornode,degreeindegree_dict.items()if

degree<=

1]

sorted_list.extend(border_nodes)

#从图中移除已排序的节点

un_di_graph.remove_nodes_from(border_nodes)

returnsorted_list

sorted_list=sort(graph)

print(sorted_list)16.3应用动态规划算法求解最优策略

defget_parent_dict(graph,sorted_list):

un_di_graph=graph.to_undirected()

#找到每个节点相邻的节点集合

neighbors_dict={node:list(un_di_graph.neighbors(node))

fornodeinun_di_graph.nodes()}

#对节点进行标号，方便查询排序先后

labeled_dict={node:ifori,nodeinenumerate(sorted_list)}

parent_dict={}

fornodeinsorted_list:

#对于每个节点，用c表示在该节点之后的相邻节点

c=

0

forneighborinneighbors_dict[node]:

iflabeled_dict[neighbor]>labeled_dict[node]:

c+=

1

#找到在该节点之后的相邻节点后，将其记录

parent_dict[node]=neighbor

#如果超过1，说明排序有误

ifc>

1:

raise

Exception('wronglabel')

returnparent_dict

parent_dict=get_parent_dict(graph,sorted_list)16.3应用动态规划算法求解最优策略判断每个节点应该使用哪一类成本函数：定义函数classif_node用于判断节点应当使用哪种成本函数，并记录每个节点的子树信息defclassify_node(graph,edge_df,sorted_list):

#定义上下游字典

pred_dict=find_predecessors_dict(

edges=edge_df[['predecessor','successor']].values)

succ_dict=find_successors_dict(

edges=edge_df[['predecessor','successor']].values)

un_di_graph=graph.to_undirected()

neighbors_dict={node:list(un_di_graph.neighbors(node))

fornodeinun_di_graph.nodes()}

labeled_dict={node:ifori,nodeinenumerate(sorted_list)}

to_eva_f_list=[]

to_eva_g_list=[]

fornodeinsorted_list:

forneighborinneighbors_dict[node]:

iflabeled_dict[neighbor]>labeled_dict[node]:

ifneighborinsucc_dict[node]:

#如果p(j)在节点j下游，则将节点标记为使用f成本函数

to_eva_f_list.append(node)

16.3应用动态规划算法求解最优策略判断每个节点应该使用哪一类成本函数：定义函数classif_node用于判断节点应当使用哪种成本函数，并记录每个节点的子树信息elifneighborinpred_dict[node]:

#如果p(j)在节点j上游，则将节点标记为使用g成本函数

to_eva_g_list.append(node)

else:

raise

Exception('wrong')

#记录子树信息

sub_pred_dict={node:[pforpinpred_dict[node]

iflabeled_dict[p]<labeled_dict[node]]

fornodeinsorted_list}

sub_succ_dict={node:[sforsinsucc_dict[node]

iflabeled_dict[s]<labeled_dict[node]]

fornodeinsorted_list}

returnto_eva_f_list,to_eva_g_list,sub_pred_dict,sub_succ_dict

to_eva_f_list,to_eva_g_list,sub_pred_dict,sub_succ_dict=classify_node(

graph,edge_df,sorted_list)16.3应用动态规划算法求解最优策略

16.3应用动态规划算法求解最优策略数据准备并初始化动态规划表：代码如下S_index={

node:np.arange(0,min(sla_dict.get(node,9999),cum_lt_dict[node])+

1)

fornodeinsorted_list}

SI_index={node:np.arange(0,cum_lt_dict[node]-lt_dict[node]+

1)

fornodeinsorted_list}

CT_index={node:np.arange(0,cum_lt_dict[node]+

1)fornodeinsorted_list}on_hand_cost={(node,CT):hc_dict[node]*ss_ct_dict[node,CT]

fornodeinsorted_listforCTinCT_index[node]}#cost_record记录出每个节点，每种策略组合（S，SI）下的成本

cost_record=defaultdict(dict)

#f_cost记录在给定S的情况下，p(j)在节点下游的节点的子树上的最小库存成本

f_cost={(node,S):-float('inf')fornodeinto_eva_f_listforSin

S_index[node]}

#f_argmin记录f_cost的最小库存成本所对应的SI

f_argmin={(node,S):-float('inf')fornodeinto_eva_f_listforSin

S_index[node]}

#g_cost记录在给定SI的情况下，p(j)在节点上游的节点的子树上的最小库存成本

g_cost={(node,SI):-float('inf')fornodeinto_eva_g_listforSIin

SI_index[node]}

#g_argmin记录g_cost的最小库存成本所对应的S

g_argmin={(node,SI):-float('inf')fornodeinto_eva_g_listforSIin

SI_index[node]}16.3应用动态规划算法求解最优策略

16.3应用动态规划算法求解最优策略

defevaluate_f(node,S):

#测试全部可能的SI

to_test_SI=np.arange(max(0,S-lt_dict[node]),

cum_lt_dict[node]-lt_dict[node]+

1)

forSIinto_test_SI:

#计算当前策略组合下的覆盖时间

CT=SI+lt_dict[node]-S

#计算当前策略组合下的库存成本

#首先是自身库存成本

cost_record[node][S,SI]=on_hand_cost[node,CT]

#如果节点有上游节点，那么需要加总上游节点子树对应的成本

iflen(sub_pred_dict[node])>

0:

forpredinsub_pred_dict[node]:

cost_record[node][S,SI]+=min(

[f_cost[pred,s]forsinS_index[pred]ifs<=SI])

#如果节点有下游节点，那么需要加总下游节点子树对应的成本

iflen(sub_succ_dict[node])>

0:

forsuccinsub_succ_dict[node]:

cost_record[node][S,SI]+=min(

[g_cost[succ,si]forsiinSI_index[succ]ifsi>=S])

#找到给定S情况下的最优的SI

cost_SI_dict={si:cost_record[node][S,si]forsiinto_test_SI}

best_SI=min(cost_SI_dict,key=cost_SI_dict.get)

#将成本记录到f_cost，将最优的SI记录到f_argmin

f_cost[node,S]=cost_SI_dict[best_SI]

f_argmin[node,S]=best_SI16.3应用动态规划算法求解最优策略

defevaluate_g(node,SI):

#测试全部可能的S

to_test_S=np.arange(0,min(sla_dict.get(node,9999),

SI+lt_dict[node])+

1)

forSinto_test_S:

#计算当前策略组合下的覆盖时间

CT=SI+lt_dict[node]-S

#计算当前策略组合下的库存成本

#首先是自身库存成本

cost_record[node][S,SI]=on_hand_cost[node,CT]

#如果节点有上游节点，那么需要加总上游节点子树对应的成本

iflen(sub_pred_dict[node])>

0:

forpredinsub_pred_dict[node]:

cost_record[node][S,SI]+=min(

[f_cost[pred,s]forsinS_index[pred]ifs<=SI])

#如果节点有下游节点，那么需要加总下游节点子树对应的成本

iflen(sub_succ_dict[node])>

0:

forsuccinsub_succ_dict[node]:

cost_record[node][S,SI]+=min(

[g_cost[succ,si]forsiinSI_index[succ]ifsi>=S])

#找到给定SI情况下的最优的S

cost_S_dict={s:cost_record[node][s,SI]forsinto_test_S}

best_S=min(cost_S_dict,key=cost_S_dict.get)

#将成本记录到g_cost，将最优的S记录到g_argmin

g_cost[node,SI]=cost_S_dict[best_S]

g_argmin[node,SI]=best_S16.3应用动态规划算法求解最优策略根据排序，遍历计算最优成本#遍历节点，除了最后一个节点外

fornodeinsorted_list[:-1]:

#如果p(j)在节点下游，则对于所有可能的S，计算f函数

ifnodeinto_eva_f_list:

forSinS_index[node]:

evaluate_f(node,S)

#如果p(j)在节点上游，则对于所有可能的S，计算g函数

ifnodeinto_eva_g_list:

forSIinSI_index[node]:

evaluate_g(node,SI)

#对于排序中最后一个节点，对于所有可能的SI，计算g函数

end_node=sorted_list[-1]

forSIinSI_index[end_node]:

evaluate_g(end_node,SI)16.3应用动态规划算法求解最优策略

end_g_cost_dict={si:g_cost[end_node,si]forsiinSI_index[end_node]}

end_node_SI=min(end_g_cost_dict,key=end_g_cost_dict.get)

end_node_S=g_argmin[end_node,end_node_SI]16.3应用动态规划算法求解最优策略使用回溯法找到最优策略：#定义最优策略字典

opt_sol={'S':{},'SI':{},'CT':{}}

#将最后一个节点的最优值存贮在最优策略中

opt_sol['SI'][end_node]=end_node_SI

opt_sol['S'][end_node]=end_no