利用Python实现供应链管理中的线性规划与资源优化——手机生产计划2:利润最大化

theskylife2024-08-21 4:03

目录

写在开头

在上篇文章中，我们探讨了如何利用生产约束条件实现成本的最小化，这为优化运营奠定了基础。然而，现实世界中的商业环境往往充满变数，单一的成本控制策略可能无法满足复杂的盈利需求。在本篇文章中，我们将深入剖析如何在多重挑战下实现利润的最大化。我们将探讨先进的利润优化策略，挖掘隐藏的盈利机会，并提供实际操作的最佳实践，帮助你在竞争激烈的市场中取得最终的成功。

1.背景描述

在激烈的市场竞争中，智能手机制造公司面临着生产和销售的挑战。公司目前生产两种型号的智能手机：型号A和型号B。公司希望通过优化生产和销售策略来最大化利润。我们将探讨如何利用线性规划模型来实现这一目标，具体包括生产优化、成本控制和利润最大化。

产品和市场概述

  • 产品A：一款高性能智能手机，适用于追求高技术和大屏幕体验的用户。
  • 产品B：一款性价比高的智能手机，目标客户是预算有限但仍希望拥有现代技术的消费者。

市场分析

公司在两个主要市场（Market1 和 Market2）销售智能手机：

  • Market1：对高性能和技术要求较高的用户市场，售价较高。
  • Market2：对预算敏感的用户市场，售价较为亲民。

数据输入

1. materials 工作表

记录了生产智能手机所需的原材料和供应量：

Material Coefficient_A Coefficient_B Supply
M1 2 1 2000
M2 3 2 2500
M3 1 3 1500
M4 4 2 3000
M5 2 4 2000
M6 5 1 4000
M7 3 2 2500
M8 2 3 2000
M9 4 2 3000
M10 1 5 1000

2. production_cost 工作表

记录了生产每款智能手机的成本：

Model Cost
A 5
B 7

3. logistics_cost 工作表

记录了不同市场和型号的物流成本：

Market Model Cost
Market1 A 10
Market1 B 12
Market2 A 8
Market2 B 11

4. selling_price 工作表

记录了不同市场中每款智能手机的售价：

Market Model Selling_Price
Market1 A 25
Market1 B 30
Market2 A 28
Market2 B 32

业务目标

为了实现利润最大化，公司需要通过以下步骤来优化其生产和销售策略：

  1. 优化生产量：决定生产型号A和型号B的最优数量，以满足市场需求并最大化利润。
  2. 分配销售：根据不同市场的售价和物流成本，优化智能手机的市场分配。

模型设定

我们将使用线性规划模型来解决这个问题。目标是最大化总利润，其中利润由产品的销售收入减去生产和物流成本。

模型参数

  • 生产能力：

    • 型号A的生产能力上限为400单位。
    • 型号B的生产能力上限为300单位。

  • 市场需求：

    • 总生产需求至少为500单位（型号A和B的总和）。

  • 市场分配：

    • 型号A和B的市场分配必须等于生产量。

2. 模型构建思路

  1. 确定决策变量

    • 生产变量：

      • production_A：生产型号A的数量
      • production_B：生产型号B的数量

    • 分配变量：

      • dist_A_market1：分配给Market1的型号A的数量
      • dist_B_market1：分配给Market1的型号B的数量
      • dist_A_market2：分配给Market2的型号A的数量
      • dist_B_market2：分配给Market2的型号B的数量

  2. 定义目标函数

    我们的目标是最大化利润，利润计算公式为：
    Profit = Total Revenue − Total Cost \text{Profit} = \text{Total Revenue} - \text{Total Cost} Profit=Total Revenue−Total Cost

    • 总收入 ：
      Total Revenue = ( Selling Price A M 1 × dist A M 1 ) + ( Selling Price B M 1 × dist B M 1 ) + ( Selling Price A M 2 × dist A M 2 ) + ( Selling Price B M 2 × dist B M 2 ) \text{Total Revenue} = (\text{Selling Price}_A^{M1} \times \text{dist}_A^{M1}) + (\text{Selling Price}_B^{M1} \times \text{dist}_B^{M1}) + (\text{Selling Price}_A^{M2} \times \text{dist}_A^{M2}) + (\text{Selling Price}_B^{M2} \times \text{dist}_B^{M2}) Total Revenue=(Selling PriceAM1×distAM1)+(Selling PriceBM1×distBM1)+(Selling PriceAM2×distAM2)+(Selling PriceBM2×distBM2)

    • 总成本 ：
      Total Cost = ( Cost A × production A ) + ( Cost B × production B ) + ( Logistics Cost A M 1 × dist A M 1 ) + ( Logistics Cost B M 1 × dist B M 1 ) + ( Logistics Cost A M 2 × dist A M 2 ) + ( Logistics Cost B M 2 × dist B M 2 ) \text{Total Cost} = (\text{Cost}_A \times \text{production}_A) + (\text{Cost}_B \times \text{production}_B) + (\text{Logistics Cost}_A^{M1} \times \text{dist}_A^{M1}) + (\text{Logistics Cost}_B^{M1} \times \text{dist}_B^{M1}) + (\text{Logistics Cost}_A^{M2} \times \text{dist}_A^{M2}) + (\text{Logistics Cost}_B^{M2} \times \text{dist}_B^{M2}) Total Cost=(CostA×productionA)+(CostB×productionB)+(Logistics CostAM1×distAM1)+(Logistics CostBM1×distBM1)+(Logistics CostAM2×distAM2)+(Logistics CostBM2×distBM2)

    • 目标函数 ：
      Profit = Total Revenue − Total Cost \text{Profit} = \text{Total Revenue} - \text{Total Cost} Profit=Total Revenue−Total Cost

  3. 设定约束条件

    • 原材料约束 ：每种原材料的消耗不能超过其供应量。设原材料的需求系数为Coefficient_A和Coefficient_B，原材料供应量为Supply：
      Coefficient A × production A + Coefficient B × production B ≤ Supply \text{Coefficient}_A \times \text{production}_A + \text{Coefficient}_B \times \text{production}_B \leq \text{Supply} CoefficientA×productionA+CoefficientB×productionB≤Supply

    • 生产能力约束 ：
      production A ≤ 400 \text{production}_A \leq 400 productionA≤400
      production B ≤ 300 \text{production}_B \leq 300 productionB≤300

    • 市场需求与分配约束：

      • 总生产需求约束：
        production A + production B ≥ 500 \text{production}_A + \text{production}_B \geq 500 productionA+productionB≥500

      • 市场分配约束：
        dist A M 1 + dist A M 2 = production A \text{dist}_A^{M1} + \text{dist}_A^{M2} = \text{production}_A distAM1+distAM2=productionA
        dist B M 1 + dist B M 2 = production B \text{dist}_B^{M1} + \text{dist}_B^{M2} = \text{production}_B distBM1+distBM2=productionB

3.实现代码

3.1 数据准备

为方便进行演示，构建实例数据代码如下：

python 复制代码 
import pandas as pd

# 创建数据
materials_data = {
    'Material': ['M1', 'M2', 'M3', 'M4', 'M5', 'M6', 'M7', 'M8', 'M9', 'M10'],
    'Coefficient_A': [2, 3, 1, 4, 2, 5, 3, 2, 4, 1],
    'Coefficient_B': [1, 2, 3, 2, 4, 1, 2, 3, 2, 5],
    'Supply': [2000, 2500, 1500, 3000, 2000, 4000, 2500, 2000, 3000, 1000]
}

production_cost_data = {
    'Model': ['A', 'B'],
    'Cost': [5, 7]
}

logistics_cost_data = {
    'Market': ['Market1', 'Market1', 'Market2', 'Market2'],
    'Model': ['A', 'B', 'A', 'B'],
    'Cost': [10, 12, 8, 11]
}

selling_price_data = {
    'Market': ['Market1', 'Market1', 'Market2', 'Market2'],
    'Model': ['A', 'B', 'A', 'B'],
    'Selling_Price': [25, 30, 28, 32]
}

# 将数据转换为DataFrame
materials_df = pd.DataFrame(materials_data)
production_cost_df = pd.DataFrame(production_cost_data)
logistics_cost_df = pd.DataFrame(logistics_cost_data)
selling_price_df = pd.DataFrame(selling_price_data)

# # 保存到Excel文件
# with pd.ExcelWriter('parameters.xlsx') as writer:
#     materials_df.to_excel(writer, sheet_name='materials', index=False)
#     production_cost_df.to_excel(writer, sheet_name='production_cost', index=False)
#     logistics_cost_df.to_excel(writer, sheet_name='logistics_cost', index=False)
#     selling_price_df.to_excel(writer, sheet_name='selling_price', index=False)

# print("数据文件 'parameters.xlsx' 已成功创建。")

3.2 进行建模

现利用Python进行建模，具体代码如下：

python 复制代码 
import pandas as pd
import pulp

# 读取数据
xls = pd.ExcelFile('parameters.xlsx')
materials_df = pd.read_excel(xls, 'materials')
production_cost_df = pd.read_excel(xls, 'production_cost')
logistics_cost_df = pd.read_excel(xls, 'logistics_cost')
selling_price_df = pd.read_excel(xls, 'selling_price')

# 初始化模型
prob = pulp.LpProblem("Profit_Maximization", pulp.LpMaximize)

# 定义生产和分配变量
production_A = pulp.LpVariable('production_A', lowBound=0, cat='Integer')
production_B = pulp.LpVariable('production_B', lowBound=0, cat='Integer')
dist_A_market1 = pulp.LpVariable('dist_A_market1', lowBound=0, cat='Integer')
dist_B_market1 = pulp.LpVariable('dist_B_market1', lowBound=0, cat='Integer')
dist_A_market2 = pulp.LpVariable('dist_A_market2', lowBound=0, cat='Integer')
dist_B_market2 = pulp.LpVariable('dist_B_market2', lowBound=0, cat='Integer')

# 获取数据
cost_A = production_cost_df.loc[production_cost_df['Model'] == 'A', 'Cost'].values[0]
cost_B = production_cost_df.loc[production_cost_df['Model'] == 'B', 'Cost'].values[0]
logistics_cost_A_market1 = logistics_cost_df.loc[(logistics_cost_df['Market'] == 'Market1') & (logistics_cost_df['Model'] == 'A'), 'Cost'].values[0]
logistics_cost_B_market1 = logistics_cost_df.loc[(logistics_cost_df['Market'] == 'Market1') & (logistics_cost_df['Model'] == 'B'), 'Cost'].values[0]
logistics_cost_A_market2 = logistics_cost_df.loc[(logistics_cost_df['Market'] == 'Market2') & (logistics_cost_df['Model'] == 'A'), 'Cost'].values[0]
logistics_cost_B_market2 = logistics_cost_df.loc[(logistics_cost_df['Market'] == 'Market2') & (logistics_cost_df['Model'] == 'B'), 'Cost'].values[0]
selling_price_A_market1 = selling_price_df.loc[(selling_price_df['Market'] == 'Market1') & (selling_price_df['Model'] == 'A'), 'Selling_Price'].values[0]
selling_price_B_market1 = selling_price_df.loc[(selling_price_df['Market'] == 'Market1') & (selling_price_df['Model'] == 'B'), 'Selling_Price'].values[0]
selling_price_A_market2 = selling_price_df.loc[(selling_price_df['Market'] == 'Market2') & (selling_price_df['Model'] == 'A'), 'Selling_Price'].values[0]
selling_price_B_market2 = selling_price_df.loc[(selling_price_df['Market'] == 'Market2') & (selling_price_df['Model'] == 'B'), 'Selling_Price'].values[0]

# 定义目标函数（利润最大化）
prob += (
    selling_price_A_market1 * dist_A_market1 +
    selling_price_B_market1 * dist_B_market1 +
    selling_price_A_market2 * dist_A_market2 +
    selling_price_B_market2 * dist_B_market2
    -
    (cost_A * production_A +
    cost_B * production_B +
    logistics_cost_A_market1 * dist_A_market1 +
    logistics_cost_B_market1 * dist_B_market1 +
    logistics_cost_A_market2 * dist_A_market2 +
    logistics_cost_B_market2 * dist_B_market2)
), "Total Profit"

# 添加约束条件
for index, row in materials_df.iterrows():
    prob += (row['Coefficient_A'] * production_A +
             row['Coefficient_B'] * production_B) <= row['Supply'], f"{row['Material']}_Supply"
prob += production_A <= 400, "Production Capacity A"
prob += production_B <= 300, "Production Capacity B"
prob += production_A + production_B >= 500, "Total Production Demand"
prob += dist_A_market1 + dist_A_market2 == production_A, "Total Distribution A"
prob += dist_B_market1 + dist_B_market2 == production_B, "Total Distribution B"

# 求解问题
prob.solve()

# 输出结果
print(f"Optimal Production for Model A (Production Line 1): {pulp.value(production_A)} units")
print(f"Optimal Production for Model B (Production Line 2): {pulp.value(production_B)} units")
print(f"Optimal Distribution to Market 1 (Model A): {pulp.value(dist_A_market1)} units")
print(f"Optimal Distribution to Market 1 (Model B): {pulp.value(dist_B_market1)} units")
print(f"Optimal Distribution to Market 2 (Model A): {pulp.value(dist_A_market2)} units")
print(f"Optimal Distribution to Market 2 (Model B): {pulp.value(dist_B_market2)} units")

3.3 结果解析

最优解

  1. 最优目标值：

    • Objective value: 7680
      • 最终计算出的目标值为 7680。这是设定的利润最大化目标函数的最优解。

  2. 生产决策：

    • Optimal Production for Model A (Production Line 1): 400.0 units
      • 产品A的最优生产量为400单位。
    • Optimal Production for Model B (Production Line 2): 120.0 units
      • 产品B的最优生产量为120单位。

  3. 市场分配：

    • Optimal Distribution to Market 1 (Model A): 0.0 units
      • 产品A分配到市场1的最优量为0单位。
    • Optimal Distribution to Market 1 (Model B): 0.0 units
      • 产品B分配到市场1的最优量为0单位。
    • Optimal Distribution to Market 2 (Model A): 400.0 units
      • 产品A分配到市场2的最优量为400单位。
    • Optimal Distribution to Market 2 (Model B): 120.0 units
      • 产品B分配到市场2的最优量为120单位。

生产与分配策略：

  • 产品A完全分配到市场2，而产品B也全部分配到市场2。这可能是因为市场2的售价或需求条件更加有利于利润最大化。
  • 市场1的分配量为0可能是由于市场1的物流成本或售价不利于整体利润最大化。

4.代码的优化

在原始代码的基础上，我可以对模型进行了几项关键优化，以增强其灵活性和实用性。

python 复制代码 
import pandas as pd
import pulp

class ProfitMaximizationModel:
    def __init__(self, file_path, config):
        """
        初始化模型类，读取数据并进行基本配置。
        
        参数:
        file_path (str): Excel文件的路径
        config (dict): 包含生产限制和总需求的配置字典
        """
        self.file_path = file_path
        self.config = config
        self.models = ['A', 'B']
        self.markets = ['Market1', 'Market2']
        self.materials_df, self.production_cost_df, self.logistics_cost_df, self.selling_price_df = self._read_data()
        self.prob = pulp.LpProblem("Profit_Maximization", pulp.LpMaximize)
        self.variables = self._define_variables()
        self.parameters = self._extract_parameters()

    def _read_data(self):
        """内部方法，用于读取Excel数据并返回各数据表的DataFrame对象。"""
        xls = pd.ExcelFile(self.file_path)
        materials_df = pd.read_excel(xls, 'materials')
        production_cost_df = pd.read_excel(xls, 'production_cost')
        logistics_cost_df = pd.read_excel(xls, 'logistics_cost')
        selling_price_df = pd.read_excel(xls, 'selling_price')
        return materials_df, production_cost_df, logistics_cost_df, selling_price_df

    def _define_variables(self):
        """内部方法，用于定义生产和分配的决策变量。"""
        variables = {}
        for model in self.models:
            variables[f'production_{model}'] = pulp.LpVariable(f'production_{model}', lowBound=0, cat='Integer')
            for market in self.markets:
                variables[f'dist_{model}_{market}'] = pulp.LpVariable(f'dist_{model}_{market}', lowBound=0, cat='Integer')
        return variables

    def _extract_parameters(self):
        """内部方法，从数据表中提取成本和价格参数。"""
        parameters = {}
        for model in self.models:
            parameters[f'cost_{model}'] = self.production_cost_df.loc[self.production_cost_df['Model'] == model, 'Cost'].values[0]
            for market in self.markets:
                parameters[f'logistics_cost_{model}_{market}'] = self.logistics_cost_df.loc[
                    (self.logistics_cost_df['Market'] == market) & (self.logistics_cost_df['Model'] == model), 'Cost'
                ].values[0]
                parameters[f'selling_price_{model}_{market}'] = self.selling_price_df.loc[
                    (self.selling_price_df['Market'] == market) & (self.selling_price_df['Model'] == model), 'Selling_Price'
                ].values[0]
        return parameters

    def _define_objective_function(self):
        """内部方法，定义目标函数（利润最大化）。"""
        profit = []
        cost = []
        for model in self.models:
            for market in self.markets:
                profit.append(self.parameters[f'selling_price_{model}_{market}'] * self.variables[f'dist_{model}_{market}'])
                cost.append(self.parameters[f'logistics_cost_{model}_{market}'] * self.variables[f'dist_{model}_{market}'])
            cost.append(self.parameters[f'cost_{model}'] * self.variables[f'production_{model}'])
        
        self.prob += pulp.lpSum(profit) - pulp.lpSum(cost), "Total Profit"

    def _define_constraints(self):
        """内部方法，添加模型的约束条件。"""
        for index, row in self.materials_df.iterrows():
            self.prob += pulp.lpSum([row[f'Coefficient_{model}'] * self.variables[f'production_{model}'] for model in self.models]) <= row['Supply'], f"{row['Material']}_Supply"

        for model in self.models:
            self.prob += self.variables[f'production_{model}'] <= self.config['production_limits'][model], f"Production Capacity {model}"
        
        self.prob += pulp.lpSum([self.variables[f'production_{model}'] for model in self.models]) >= self.config['total_demand'], "Total Production Demand"

        for model in self.models:
            self.prob += pulp.lpSum([self.variables[f'dist_{model}_{market}'] for market in self.markets]) == self.variables[f'production_{model}'], f"Total Distribution {model}"

    def solve(self):
        """执行求解过程并返回结果。"""
        self._define_objective_function()
        self._define_constraints()
        self.prob.solve()
        return {v.name: pulp.value(v) for v in self.prob.variables()}

# 示例使用方法
if __name__ == "__main__":
    config = {
        "production_limits": {
            "A": 400,
            "B": 300
        },
        "total_demand": 500
    }

    # 初始化模型并求解
    model = ProfitMaximizationModel('parameters.xlsx', config)
    results = model.solve()
    print(results)

写在最后

通过本文的介绍，您已经了解了如何使用Python中的线性规划工具快速构建并求解一个利润最大化模型，并通过灵活的配置和自定义约束条件，轻松应对各种复杂的业务场景。无论您是希望优化企业的生产计划，还是精细化管理资源分配，这个模型都能为您提供强有力的支持。未来，您可以根据自身需求，继续扩展和优化这个模型，实现更加精准和高效的决策支持。

相关推荐
Null箘3 分钟前
从零创建一个 Django 项目
后端·python·django
云空7 分钟前
《解锁 Python 数据挖掘的奥秘》
开发语言·python·数据挖掘
玖年39 分钟前
Python re模块 用法详解 学习py正则表达式看这一篇就够了 超详细
python
岑梓铭43 分钟前
(CentOs系统虚拟机)Standalone模式下安装部署“基于Python编写”的Spark框架
linux·python·spark·centos
游客5201 小时前
opencv中的各种滤波器简介
图像处理·人工智能·python·opencv·计算机视觉
Eric.Lee20211 小时前
moviepy将图片序列制作成视频并加载字幕 - python 实现
开发语言·python·音视频·moviepy·字幕视频合成·图像制作为视频
Dontla1 小时前
vscode怎么设置anaconda python解释器（anaconda解释器、vscode解释器）
ide·vscode·python
qq_529025292 小时前
Torch.gather
python·深度学习·机器学习
数据小爬虫@2 小时前
如何高效利用Python爬虫按关键字搜索苏宁商品
开发语言·爬虫·python
Cachel wood2 小时前
python round四舍五入和decimal库精确四舍五入
java·linux·前端·数据库·vue.js·python·前端框架
热门推荐
01〔AI 绘画〕Stable Diffusion 之 解决绘制多人或面部很小的人物时面部崩坏问题 篇02ARM学习（31）编译器对overlay方式的支持03玄机平台应急响应—webshell查杀04解决java读取EXCEL数据变成科学计数法的问题05校验 GPT-4 真实性的三个经典问题：快速区分 GPT-3.5 与 GPT-4，并提供免费测试网站06Docker 夺命连环 15 问07DisplayPort AltMode On Type-c协议_Ver2.0(学习笔记)08基于大语言模型（LLM）的合成数据生成、策展和评估的综述09(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明106个主流的工业3D管道设计软件