《现代库存管理：模型、算法与Python实现》 课件 第17章-某家电企业H的制造网络库存优化实战

现代库存管理：模型、算法与Python实现第17章某家电企业H的制造网络库存优化实战17.1背景介绍企业H是一家大型的家电制造商，旗下产品覆盖了绝大部分的家庭电器：同一种原材料一般支撑多个半成品、成品的生产，H公司一直以来主要在原材料上放置安全库存企业的发展趋势和转型需求：各大渠道商对工厂的交付时间有了更高的要求，需要将制造网络中的安全库存前置17.1背景介绍公司挑选两款“明星”产品以及它们的生产涉及的所有半成品和原材料，利用物料清单、各物料的持货成本、成品需求的预测均值和误差，以及工厂对客户的承诺服务时间等数据，以这两个产品的制造网络为基础，搭建出全网络安全库存优化方案的原型，探究如下三个问题：应该选择网络的哪些节点放置安全库存（位置），以及放置多少安全库存（量）？与安全库存全部前置在成品的策略相比，全局最优的策略能否显著降低总安全库存成本？对客户的承诺服务时间对总安全库存成本的影响有多大？由于制造中存在很多通用件，在本案例中，使用有向无环图对家电企业H的两个成品的制造网络进行建模，并使用分段线性函数近似算法，建立混合整数规划来求解相应的承诺服务模型17.2数据导入及预处理#导入网络分析包

importnetworkxasnx

#导入数据分析包

importpandasaspd

#导入第10章的几个算法

fromchapter14_network_basicimportcal_cum_lt,cal_demand_bound

#导入copt优化求解包

fromcoptpyimport*

importmatplotlib.pyplotasplt

importseabornassns

sns.set_theme(style='darkgrid')

importwarnings

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

data_dir=

'../../data/manufacture/'

#读取两个需求节点（成品）的需求数据

demand_df=pd.read_csv(data_dir+

'manufacture_demand_df.csv')

#读取制造网络的节点数据

node_df=pd.read_csv(data_dir+

'manufacture_node_df.csv')

#读取制造网络的边数据

edge_df=pd.read_csv(data_dir+

'manufacture_edge_df.csv')17.2数据导入及预处理数据集概况：demand_df表：展示了两个成品的需求信息node_idmeanstd0N00190163.1164901.3218181N00166113.9650239.74188217.2数据导入及预处理数据集概况：edge_df表：BOM的边信息表’predecessor’：上游节点’successor’：下游节点’quantity’：配比node_df表：BOM的节点信息表’node_id’：节点的id’lt’：提前期’hc’：单位持货成本’sla’：对客户的承诺服务时间predecessorsuccessorquantity0N002230N0019011.0001N001693N0019011.0002N001664N0016931.2003N000519N0016930.0014N000416N0016930.001node_idlthcsla0N00160840.478034NaN1N00274740.860900NaN2N00302420.483988NaN3N00096860.311728NaN4N00052890.807896NaN17.2数据导入及预处理数据集概况：利用NetworkX，对H企业的制造BOM进行可视化展示：尽管只有两个成品，整个制造网络依然非常复杂，存在很多共享节点17.2数据导入及预处理数据集预处理：计算出每个节点的累计提前期调用计算需求上界的函数cal_demand_bound计算服务水平为0.95时的需求上界表将后续要反复使用的数据转换成字典格式数据集预处理代码如下：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.head())17.2数据导入及预处理数据集预处理代码：all_nodes=set(node_df['node_id'])

#提前期

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

#累计提前期

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

#单位持货成本

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

#对客户承诺服务时间sla

sla_dict=dict(zip(node_df['node_id'],node_df['sla']))

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

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

demand_bound_df[['node_id','time','ss_qty']].values}17.3应用分段线性函数近似算法求解近似最优的策略

17.3应用分段线性函数近似算法求解近似最优的策略

17.3应用分段线性函数近似算法求解近似最优的策略代码如下：defcal_ar_br(demand_bound_df):

#对时间取差

demand_bound_df['t_diff']=demand_bound_df['time'].diff()

demand_bound_df.loc[demand_bound_df['time']==

0,'t_diff']=

0

#对需求上界取差

demand_bound_df['db_diff']=demand_bound_df['demand_bound'].diff()

demand_bound_df.loc[demand_bound_df['time']==

0,'db_diff']=

0

#根据ar和br的公式，计算ar与br

demand_bound_df['ar']=demand_bound_df['db_diff']/

\

demand_bound_df['t_diff']-

\

demand_bound_df['mean']

demand_bound_df['br']=demand_bound_df['demand_bound']-

\

demand_bound_df['mean']*

\

demand_bound_df['time']-

\

demand_bound_df['ar']*demand_bound_df['time']

demand_bound_df.loc[demand_bound_df['time']==

0,'ar']=

0

demand_bound_df.loc[demand_bound_df['time']==

0,'br']=

0

#转换成字典格式，方便后续读取

ar_dict={(node,time):arfornode,time,ar

indemand_bound_df[['node_id','time','ar']].values}

br_dict={(node,time):brfornode,time,br

indemand_bound_df[['node_id','time','br']].values}

returnar_dict,br_dict

ar_dict,br_dict=cal_ar_br(demand_bound_df)17.3应用分段线性函数近似算法求解近似最优的策略代码如下：jt_list=list(ar_dict.keys())

jt_dict={j:list(range(0,int(cum_lt_dict[j])+

1))forjinall_nodes}#生成COPT的环境

env=Envr()

#建立空的模型

m=env.createModel('pwl')CardinalOptimizerv4.0.2.BuilddateFeb232022

CopyrightCardinalOperations2022.AllRightsReserved#服务响应时间

S=m.addVars(all_nodes,vtype=COPT.CONTINUOUS,lb=0,nameprefix='S')

#被服务时间

SI=m.addVars(all_nodes,vtype=COPT.CONTINUOUS,lb=0,nameprefix='SI')

#覆盖时间

CT=m.addVars(all_nodes,vtype=COPT.CONTINUOUS,lb=0,nameprefix='CT')

#用来控制只选择一段的0-1变量

U=m.addVars(jt_list,vtype=COPT.BINARY,nameprefix='U')

#用于近似覆盖时间的变量

Z=m.addVars(jt_list,vtype=COPT.CONTINUOUS,lb=0,nameprefix='Z')17.3应用分段线性函数近似算法求解近似最优的策略代码如下：m.setObjective(quicksum(

hc_dict[j]*(ar_dict[j,t]*Z[j,t]+br_dict[j,t]+U[j,t])forj,t

injt_list),COPT.MINIMIZE)m.addConstrs(

(CT[j]==quicksum(Z[j,t]fortinjt_dict[j])forjinall_nodes),

nameprefix='approx_CT')m.addConstrs(((t-

1)*U[j,t]<=Z[j,t]forj,tinjt_list),

nameprefix='time_interval_lhs')

m.addConstrs((t*U[j,t]>=Z[j,t]forj,tinjt_list),

nameprefix='time_interval_rhs')m.addConstrs((quicksum(U[j,t]fortinjt_dict[j])==

1

forjinall_nodes)

,nameprefix='choose_one')17.3应用分段线性函数近似算法求解近似最优的策略代码如下：m.addConstrs((CT[j]==SI[j]+lt_dict[j]-S[j]forjinall_nodes),

nameprefix='covering_time')m.addConstrs((SI[succ]-S[pred]>=

0

for(pred,succ)inedge_df[[

'predecessor','successor']].values),nameprefix='edge')m.addConstrs((S[j]<=int(sla_dict[j])forjinall_nodes

ifpd.notnull(sla_dict[j])),nameprefix='sla')#整数规划启发式算法的参数

m.setParam(COPT.Param.HeurLevel,3)

#求解精度

m.setParam(COPT.Param.RelGap,0.01)

m.solve()17.3应用分段线性函数近似算法求解近似最优的策略策略成本比较：计算策略的安全库存成本，并与将安全库存全部放置在成品的策略进行比较#计算网络最优策略的成本

opt_ss_dict={node:ss_ct_dict.get((node,CT),0)

fornode,CTinopt_sol['CT'].items()}

opt_ss_cost=sum([hc_dict[node]*opt_ss_dict[node]

fornodeinall_nodes])

#计算将安全库存都放置在成品的安全库存成本

product_node_df=node_df[node_df.sla.notna()]

product_node_df['CT']=product_node_df['cum_lt']-product_node_df['sla']

product_ct_dict=dict(zip(product_node_df['node_id'],product_node_df['CT']))

product_ss_dict={node:ss_ct_dict.get((node,CT),0)

fornode,CTinproduct_ct_dict.items()}

product_ss_cost=sum([hc_dict[node]*product_ss_dict[node]

fornodeinproduct_node_df['node_id']])

print("使用安全库存全部放置在成品的策略的安全库存成本为%.2f"

%product_ss_cost)

print("使用网络最优策略的安全库存