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

相关推荐
HPC_fac1305206781625 分钟前
以科学计算为切入点：剖析英伟达服务器过热难题
服务器·人工智能·深度学习·机器学习·计算机视觉·数据挖掘·gpu算力
网易独家音乐人Mike Zhou3 小时前
【卡尔曼滤波】数据预测Prediction观测器的理论推导及应用 C语言、Python实现（Kalman Filter）
c语言·python·单片机·物联网·算法·嵌入式·iot
安静读书3 小时前
Python解析视频FPS(帧率)、分辨率信息
python·opencv·音视频
小二·5 小时前
java基础面试题笔记（基础篇）
java·笔记·python
小喵要摸鱼6 小时前
Python 神经网络项目常用语法
python
一念之坤7 小时前
零基础学Python之数据结构 -- 01篇
数据结构·python
wxl7812278 小时前
如何使用本地大模型做数据分析
python·数据挖掘·数据分析·代码解释器
NoneCoder8 小时前
Python入门（12）--数据处理
开发语言·python
LKID体9 小时前
Python操作neo4j库py2neo使用（一）
python·oracle·neo4j
小尤笔记9 小时前
利用Python编写简单登录系统
开发语言·python·数据分析·python基础
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作