2024年美国大学生数学建模竞赛（E题）财产保险建模|MCDA/随机森林建模解析，小鹿学长带队指引全代码文章与思路_保险利润受极端灾害影响的多目标线性回归模型

我是鹿鹿学长，就读于上海交通大学，截至目前已经帮500+人完成了建模与思路的构建的处理了～
本文运用利用时间序列和强化学习结合DQN算法，解决保险业可持续性问题；采用MCDA和随机森林，应对地产业保险挑战；运用电子表格法处理历史建筑保护决策；结合敏感性分析和可视化图表，深度解读数据。
创新思路、卓越手法，鹿鹿学长构建前瞻性建模，成就你的美赛夺奖之路！
完整内容可以在文章末尾领取！

问题重述及要点

问题1: 财产保险行业的挑战与可持续性

1. 现状描述:

   • 描述当前财产保险行业面临的挑战，包括极端天气事件频发导致的损失增加和保险理赔的上升趋势。

2. 气候变化对行业的影响:

   • 分析气候变化对财产保险行业的影响，包括预期未来天气事件的频率和严重程度。

3. 可持续性考虑:

   • 探讨保险公司如何应对这些挑战，以确保其业务的可持续性，包括调整保费、承保政策和提供更多风险管理服务等方面。

4. 保险模型的建立:

   • 讨论建立一个模型的必要性，以帮助保险公司评估承保决策的风险和潜在收益，以及如何确保保险行业的长期健康。

问题2: 保险模型的应用

1. 模型要素和条件:

   • 确定建立模型时需要考虑的关键因素和条件，例如地理位置、历史天气事件数据、保险保障缺口等。

2. 决策建议:

   • 提出在何种条件下保险公司应该承保政策，以及何时应该避免或限制承保。

3. 两个地区的应用案例:

   • 使用模型对两个不同大陆上经历极端天气事件的地区进行评估，并比较模型在不同情境下的应用结果。

问题3: 社区领导者面临的挑战与建议

1. 文化或社区重要性建筑物保护的挑战:

   • 讨论社区领导者在保护文化或社区重要性建筑物时面临的挑战，包括如何平衡保护和发展的需求。

2. 保护模型的建立:

   • 探讨建立一个保护模型的重要性，以帮助社区领导者确定哪些建筑物应该受到保护，以及如何保护。

3. 建议与计划:

   • 提出建议和计划，包括保护措施的范围、时间表和成本估算，以及如何平衡保护和发展的利益。

问题4: 历史地标的保护与发展

1. 历史地标的价值评估:

   • 选择一座历史地标，分析其在极端天气事件频发地区的价值，以及保护和发展的必要性。

2. 社区建议信:

   • 撰写一封给社区的建议信，提出关于历史地标的保护和发展的计划，包括保护措施、时间表和成本预算。

问题一

综合建模思路：使用时间序列和深度 Q 网络（DQN）解决财产保险行业可持续性问题：

一、数据收集与预处理：

1. 时间序列数据:

   • 收集财产保险行业的历史数据，包括极端天气事件、保险理赔、保费收入、市场指标等。

2. 天气事件数据:

   • 获取详细的天气事件数据，包括类型、频率、地理分布等，以便将其纳入模型。

3. 市场经济数据:

   • 收集相关的市场经济数据，例如通货膨胀率、利率、GDP等，以更全面地了解外部因素的影响。

二、时间序列分析：

4. 趋势和季节性分析:

   • 对时间序列数据进行趋势和季节性分析，以理解极端天气事件对理赔和保费的长期和短期影响。

5. 相关性分析:

   • 确定不同因素之间的相关性，特别是天气事件与理赔之间的关联。

三、强化学习模型建立：

6. 状态表示:

   • 将状态空间中的各个因素编码成可供神经网络处理的状态表示。

7. DQN 网络结构:

   • 构建深度 Q 网络，包括输入层、隐藏层和输出层，确保网络结构能够处理复杂的状态信息。

8. 动作空间定义:

   • 将承保政策的选择映射到模型的输出，确保动作空间能够覆盖保险公司可能的策略。

9. 经验回放:

   • 使用经验回放机制，从过去的决策和奖励中学习，以减少样本相关性，提高训练效果。

10. 目标网络:

    • 实施目标网络来稳定训练过程，将目标 Q 值的计算与当前网络的参数分离。

四、训练与优化：

11. 奖励函数调整:

    • 不断调整奖励函数，以确保模型能够在保险公司的整体利益和可持续性之间找到平衡。

12. 训练过程:

    • 在历史数据上进行训练，逐步优化网络参数，以最大化长期奖励。

13. 性能评估:

    • 使用交叉验证或保持一部分数据用于测试，评估模型在未见过的数据上的性能。

五、结果解释与决策支持：

14. 策略输出:

    • 解释 DQN 模型的输出，包括每个状态下选择的承保政策以及相应的 Q 值。

15. 决策支持系统整合:

    • 将训练好的 DQN 模型整合到决策支持系统中，为保险公司提供实时决策支持。

16. 反馈循环:

    • 建立一个反馈循环机制，以定期监控模型性能并进行调整，确保模型能够适应不断变化的环境。

import numpy as np
import tensorflow as tf
from collections import deque

# 定义深度 Q 网络
class DQNNetwork(tf.keras.Model):
    def __init__(self, state_size, action_size):
        super(DQNNetwork, self).__init__()
        self.fc1 = tf.keras.layers.Dense(64, activation='relu')
        self.fc2 = tf.keras.layers.Dense(64, activation='relu')
        self.output_layer = tf.keras.layers.Dense(action_size, activation='linear')

    def call(self, state):
        x = self.fc1(state)
        x = self.fc2(x)
        return self.output_layer(x)

# 定义经验回放缓存
#见完整版

# 定义DQN Agent
class DQNAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.gamma = 0.99  # 折扣因子
        self.epsilon = 1.0  # 探索-利用权衡的初始值
        self.epsilon_decay = 0.995  # 探索-利用权衡的衰减率
        self.epsilon_min = 0.01  # 探索-利用权衡的最小值
        self.learning_rate = 0.001  # 学习率
        self.batch_size = 64  # 批处理大小
        self.memory = ReplayBuffer(capacity=10000)
        self.model = DQNNetwork(state_size, action_size)
        self.target_model = DQNNetwork(state_size, action_size)
        self.optimizer = tf.keras.optimizers.Adam(learning_rate=self.learning_rate)

    def select_action(self, state):
        if np.random.rand() <= self.epsilon:
            return np.random.choice(self.action_size)
        q_values = self.model.predict(state)
        return np.argmax(q_values[0])

    def remember(self, state, action, reward, next_state, done):
        self.memory.add((state, action, reward, next_state, done))

    def replay(self):
        if len(self.memory.buffer) < self.batch_size:
            return

        minibatch = self.memory.sample(self.batch_size)
        states, targets = [], []

        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                target = reward + self.gamma * np.amax(self.target_model.predict(next_state)[0])

            target_f = self.model.predict(state)
            target_f[0][action] = target
            states.append(state[0])
            targets.append(target_f[0])

        self.model.fit(np.array(states), np.array(targets), epochs=1, verbose=0)

    def target_train(self):
        self.target_model.set_weights(self.model.get_weights())

    def decay_epsilon(self):
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

在解决问题一的过程中，可以创建多种图表来帮助可视化和理解财产保险行业的可持续性问题。以下是一些图表类型：

1. 时间序列图:

   • 显示时间序列数据，包括极端天气事件的频率、保险理赔金额和保费收入。这有助于识别趋势和季节性模式。

2. 相关性矩阵:

   • 通过绘制相关性矩阵，展示不同因素之间的关联程度。特别是天气事件与理赔之间的相关性，以及其他市场经济因素的影响。

3. 深度 Q 网络结构图:

   • 如果需要，你可以绘制深度 Q 网络的结构图，显示输入层、隐藏层和输出层的连接关系。这有助于理解模型的复杂性。

4. 保险承保策略图:

   • 可以绘制图表来展示模型在不同状态下推荐的承保策略，以及相应的 Q 值。这有助于解释模型输出。

5. 奖励函数调整图:

   • 如果你不断调整奖励函数，可以通过图表来展示奖励函数的变化对模型性能的影响。这有助于找到平衡点。

6. 训练过程图:

   • 可以绘制训练过程中模型性能的变化曲线，以及模型在测试数据上的表现。这有助于评估模型的泛化能力。

7. 决策支持系统界面:

   • 如果将模型整合到决策支持系统中，可以创建界面截图或流程图，显示模型输出是如何为决策者提供支持的。

问题二（MCDA+随机森林）

将多标准决策分析（MCDA）结合随机森林进行问题二的建模需要一系列步骤。以下是详细的思路：
好的，让我们对每个步骤进行更详细的说明，并结合公式：

一、问题定义和准备工作：

1. 明确定义决策目标:

   • 假设我们有四个目标：文化重要性（C），历史重要性（H），经济贡献（E），社区关联（S）。

2. 数据准备:

   • 收集建筑物的相关数据，并将其转化为可量化的形式。设建筑物 i 的数据为 $X_i=[X_{iC},X_{iH},X_{iE},X_{iS}]$。

二、MCDA模型建立：

3. 指标权重确定:

   • 使用 AHP 或专家意见确定指标的权重 $W=[W_C,W_H,W_E,W_S]$，满足 ${\sum }_{i=1}^4{W}_i=1$。

4. 评价矩阵建立:

   • 建立评价矩阵 $M$，其中 $M_{ij}$ 表示建筑物 i 在目标 j 上的得分。

   $$M=\left[\begin{array}{cccc}{M}_{11}& M_{12}& M_{13}& M_{14}\\ M_{21}& M_{22}& M_{23}& M_{24}\\ ⋮& ⋮& ⋮& ⋮\\ M_{n1}& M_{n2}& M_{n3}& M_{n4}\end{array}\right]$$

5. 综合评分计算:

   • 计算每个建筑物的综合评分 $S_i$。

   $$S_i=\sum _{j=1}^4{W}_j\cdot M_{ij}$$

三、随机森林模型建立：

6. 准备训练数据集:

   • 创建一个训练数据集，包括建筑物的特征 $X_i$ 作为输入，而MCDA模型中计算得到的综合评分作为输出。 $D=\{(X_1,S_1),(X_2,S_2),...,(X_n,S_n)\}$

7. 随机森林模型训练:

   • 训练一个随机森林模型，其中 $RF(X_i)$ 预测建筑物的综合评分。

8. 模型评估:

   • 使用测试数据集评估模型性能。

四、整合MCDA和随机森林：

9. MCDA输出与随机森林预测的整合:

   • 将MCDA计算得到的综合评分 $S_i$ 与随机森林模型的预测结果 $RF(X_i)$ 整合。

   $$FinalScor{e}_i=\alpha \cdot S_i+(1-\alpha )\cdot RF(X_i)$$

   其中，$\alpha$ 是整合权重，表示MCDA模型的相对重要性。

10. 结果解释:

    • 解释最终的保护建议，包括建筑物的文化、历史、经济和社区重要性，以及随机森林模型对建筑物保护程度的预测。

11. 调整和优化:

    • 根据实际需求和反馈，调整MCDA权重、随机森林参数等，以优化模型性能。

五、结果可视化和报告:

12. 生成图表和报告:
    • 使用适当的图表和报告，将整个模型的结果清晰地呈现，以便决策者理解和接受建筑物的保护建议。

在整个过程中，确保对权重、参数和整合方式进行适当的敏感性分析，以确保模型的鲁棒性和实用性。

import numpy as np
from sklearn.ensemble import RandomForestRegressor

# 生成模拟数据
np.random.seed(42)
num_buildings = 100
num_features = 4

# 模拟建筑物特征
X = np.random.rand(num_buildings, num_features)

# 模拟MCDA得分（0到1之间的随机数）
MCDA_scores = np.random.rand(num_buildings)

# 模拟每个建筑物的真实保护程度标签（0到1之间的随机数）
true_protection_labels = np.random.rand(num_buildings)

# 随机森林模型训练
def train_random_forest(X_train, y_train):
    rf_model = RandomForestRegressor(n_estimators=100, random_state=42)
    rf_model.fit(X_train, y_train)
    return rf_model

# 随机森林模型预测
def predict_with_random_forest(rf_model, X_test):
    return rf_model.predict(X_test)

# MCDA模型建立
#见完整版

# 模型训练
rf_model = train_random_forest(X, true_protection_labels)

# 新建筑物特征（用于演示）
new_building_feature = np.random.rand(1, num_features)

# MCDA模型得分计算
mcda_score = calculate_mcda_scores(new_building_feature)

# 随机森林模型预测
rf_prediction = predict_with_random_forest(rf_model, new_building_feature)

# 整合MCDA和随机森林得分
integration_alpha = 0.7
final_score = integrate_scores(integration_alpha, mcda_score, rf_prediction)

# 打印结果
print("MCDA Score:", mcda_score[0])
print("RF Prediction:", rf_prediction[0])
print("Integrated Score:", final_score[0])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

在解决问题二的情境中，你可以使用多种图形来可视化不同方面的数据和模型结果。以下是一些可能有用的图表示例：

1. 条形图/饼图：

   • 用于展示建筑物的不同方面的权重和重要性。可以用于显示文化、历史、经济和社区因素的相对权重。

2. 散点图：

   • 用于展示建筑物的特征与MCDA得分之间的关系。每个点表示一个建筑物，横轴表示某个特征，纵轴表示MCDA得分。

3. 随机森林模型的特征重要性图：

   • 随机森林模型提供了每个特征对于模型预测的相对重要性。这可以通过绘制一个条形图来展示。

4. 整合得分图：

   • 使用整合MCDA和随机森林得分的柱状图或折线图。可以将每个建筑物的MCDA得分、随机森林预测以及整合得分进行比较。

5. 热力图：

   • 如果有地理信息数据，可以使用热力图来展示建筑物的分布以及其在地理空间上的整合得分。

6. 决策树可视化（针对单颗树）：

   • 随机森林是多个决策树的集合，你可以选择其中一颗树进行可视化，以更好地理解模型的决策过程。

7. ROC曲线或PR曲线：

   • 用于评估随机森林模型的性能，特别是在不同阈值下的召回率和准确率。

8. MCDA模型输出图：

   • 用于展示MCDA模型输出的建筑物得分分布。

import matplotlib.pyplot as plt
import seaborn as sns

# 设置Seaborn风格
sns.set(style="whitegrid")

# 1. 条形图/饼图
weights = [0.25, 0.25, 0.25, 0.25]  # 替换为你的实际权重
labels = ['Culture', 'History', 'Economy', 'Community']
plt.figure(figsize=(8, 6))
plt.bar(labels, weights, color='skyblue')
plt.title('Weights of Different Aspects')
plt.xlabel('Aspects')
plt.ylabel('Weights')
plt.show()

# 2. 散点图
plt.figure(figsize=(8, 6))
sns.scatterplot(x=X[:, 0], y=MCDA_scores)
plt.title('Scatter Plot between Feature 1 and MCDA Scores')
plt.xlabel('Feature 1')
plt.ylabel('MCDA Scores')
plt.show()

# 3. 随机森林模型的特征重要性图
feature_importances = rf_model.feature_importances_
plt.figure(figsize=(8, 6))
sns.barplot(x=feature_importances, y=['Feature 1', 'Feature 2', 'Feature 3', 'Feature 4'], color='lightgreen')
plt.title('Random Forest Feature Importance')
plt.xlabel('Importance')
plt.ylabel('Features')
plt.show()

# 4. 整合得分图
building_names = ['Building 1', 'Building 2', 'Building 3', 'Building 4']  # 替换为实际建筑物名
integrated_scores = [0.8, 0.6, 0.7, 0.9]  # 替换为实际整合得分
plt.figure(figsize=(8, 6))
plt.bar(building_names, integrated_scores, color='salmon')
plt.title('Integrated Scores of Buildings')
plt.xlabel('Buildings')
plt.ylabel('Integrated Scores')
plt.show()

# 5. 热力图（示例，需要地理信息数据）
plt.figure(figsize=(10, 8))
sns.heatmap(data=building_data, annot=True, cmap='YlGnBu')
plt.title('Integrated Scores Heatmap')
plt.show()

# 其他图表略，根据需要选择性绘制

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

问题三

问题三涉及建立一个保险公司的模型，以确定何时承保房地产保险，尤其是在极端天气事件频发的地区。为了解决这个问题，可以考虑使用强化学习算法，尤其是基于时间序列数据的方法。以下是一种可能的方法：

使用时间序列结合强化学习算法解决问题三的详细思路：

1. 问题建模:

将问题转化为马尔可夫决策过程（MDP），定义MDP元素：$S$（状态空间）、$A$（动作空间）、$P$（状态转移概率）、$R$（奖励函数）、$\gamma$（折扣因子）。

2. 定义状态（State）:

定义状态空间 $S$，包括房地产市场指标和极端天气事件历史。例如：
$$S_t=[M_t,W_t]$$
其中，$M_t$ 表示在时刻 $t$ 的房地产市场指标，$W_t$ 表示在时刻 $t$ 的天气事件历史。

3. 定义动作（Action）:

定义动作空间 $A$，包括保险公司可以采取的各种决策动作。例如：
$$A_t=[I_t,P_t]$$
其中，$I_t$ 表示在时刻 $t$ 是否承保，$P_t$ 表示在时刻 $t$ 的保费水平调整。

4. 定义奖励（Reward）:

定义奖励函数 $R(s,a,s^{\prime })$，表示在状态 $s$ 下采取动作 $a$ 后转移到状态 $s^{\prime }$ 所获得的奖励。可以考虑多个因素，例如：
$$R(s,a,s^{\prime })=\text{MarketPerformance}(s,s^{\prime })+\text{Profit}(s,a)-\text{RiskPenalty}(s^{\prime })$$
其中，$\text{MarketPerformance}$ 表示市场表现的奖励，$\text{Profit}$ 表示保险公司的利润，$\text{RiskPenalty}$ 表示面临的风险。

5. 建立强化学习模型:

选择一个强化学习算法，例如深度Q网络（DQN）。DQN 的 Q 值函数可以表示为：
$$Q(s,a)=\mathbb{E}\left[R_t+\gamma \underset{a^{\prime }}{\max }Q(s^{\prime },a^{\prime })\mid s,a\right]$$
这里，$R_t$ 是时刻 $t$ 的奖励，$\gamma$ 是折扣因子，$a^{\prime }$ 是在下一状态 $s^{\prime }$ 下的动作。

6. 模型训练:

使用历史数据进行强化学习模型的训练。通过最小化 Q 值的均方误差来更新模型参数：
$$\text{Loss}=\mathbb{E}\left[{\left(Q(s,a)-(R_t+\gamma \underset{a^{\prime }}{\max }Q(s^{\prime },a^{\prime }))\right)}^2\right]$$

7. 模型评估:

通过验证集或历史数据评估模型的性能。可以使用累积奖励、平均奖励等指标来评估模型的效果。

8. 决策制定:

使用训练好的强化学习模型进行决策制定。在每个时刻根据当前状态选择最优的动作：
$$a^{\ast }=\arg \underset{a}{\max }Q(s,a)$$

9. 实时决策:

将模型部署到实时环境中，使用实时数据进行决策。在每个时刻更新模型的状态，选择最优动作。

10. 调整和优化:

根据实际情况对模型进行调整和优化。可以采用在线学习的方式，不断更新模型以适应新的市场变化。

import numpy as np
import tensorflow as tf
from collections import deque
import random

# 定义强化学习模型
class DQNAgent:
    def __init__(self, state_size, action_size):
        self.state_size = state_size
        self.action_size = action_size
        self.memory = deque(maxlen=2000)
        self.gamma = 0.95  # 折扣因子
        self.epsilon = 1.0  # 探索率
        self.epsilon_decay = 0.995
        self.epsilon_min = 0.01
        self.learning_rate = 0.001
        self.model = self.build_model()

#见完整版

    def remember(self, state, action, reward, next_state, done):
        self.memory.append((state, action, reward, next_state, done))

    def act(self, state):
        if np.random.rand() <= self.epsilon:
            return np.random.choice(self.action_size)
        act_values = self.model.predict(state)
        return np.argmax(act_values[0])

    def replay(self, batch_size):
        minibatch = random.sample(self.memory, batch_size)
        for state, action, reward, next_state, done in minibatch:
            target = reward
            if not done:
                target = (reward + self.gamma * np.amax(self.model.predict(next_state)[0]))
            target_f = self.model.predict(state)
            target_f[0][action] = target
            self.model.fit(state, target_f, epochs=1, verbose=0)
        if self.epsilon > self.epsilon_min:
            self.epsilon *= self.epsilon_decay

# 模拟环境
class Environment:
    def __init__(self):
        self.state_size = 8  # 替换为实际状态空间大小
        self.action_size = 2  # 替换为实际动作空间大小
        self.episodes = 1000

    def reset(self):
        return np.random.random(self.state_size)

    def step(self, action):
        # 模拟环境的状态转移和奖励计算
        next_state = np.random.random(self.state_size)
        reward = np.random.random()
        done = False  # 根据实际情况判断是否结束
        return next_state, reward, done, {}

# 主程序
env = Environment()
state_size = env.state_size
action_size = env.action_size
agent = DQNAgent(state_size, action_size)
batch_size = 32

for episode in range(env.episodes):
    state = env.reset()
    state = np.reshape(state, [1, state_size])

    for time in range(500):  # 最大时间步长
        action = agent.act(state)
        next_state, reward, done, _ = env.step(action)
        next_state = np.reshape(next_state, [1, state_size])
        agent.remember(state, action, reward, next_state, done)
        state = next_state

        if done:
            break

    if len(agent.memory) > batch_size:
        agent.replay(batch_size)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

在强化学习中，可视化是一种重要的工具，可以帮助你理解代理的学习过程和结果。以下是一些可视化的方法，你可以根据实际需要选择适合你问题的方式：

1. 奖励曲线:
   • 画出每个时刻或每个回合的奖励曲线，以观察代理学习的效果。
   • 使用matplotlib等库进行绘图。

import matplotlib.pyplot as plt

def plot_rewards(rewards):
    plt.plot(rewards)
    plt.xlabel('Episode')
    plt.ylabel('Total Reward')
    plt.title('Reward Curve')
    plt.show()
1
2
3
4
5
6
7
8

2. 探索率曲线:
   • 如果你在训练中使用了探索率（epsilon-greedy策略），可以绘制探索率的变化曲线。

def plot_epsilon(epsilon_values):
    plt.plot(epsilon_values)
    plt.xlabel('Episode')
    plt.ylabel('Exploration Rate (Epsilon)')
    plt.title('Exploration Rate Curve')
    plt.show()
1
2
3
4
5
6

3. Q值分布:
   • 绘制代理在状态空间中学到的Q值分布，以观察其对状态-动作对的估计。

def plot_q_distribution(q_values):
    plt.hist(q_values, bins=30)
    plt.xlabel('Q-Values')
    plt.ylabel('Frequency')
    plt.title('Q-Value Distribution')
    plt.show()
1
2
3
4
5
6

4. 动作分布:
   • 对于每个状态，绘制代理选择的动作分布。

def plot_action_distribution(action_distribution):
    plt.bar(range(len(action_distribution)), action_distribution)
    plt.xlabel('Actions')
    plt.ylabel('Probability')
    plt.title('Action Distribution')
    plt.show()
1
2
3
4
5
6

5. 状态空间映射:
   • 如果状态空间是低维的，可以通过散点图等方式将状态映射到二维平面，观察状态空间中的聚类情况。

def plot_state_space(states):
    plt.scatter(states[:, 0], states[:, 1], c='blue', marker='o')
    plt.xlabel('State Dimension 1')
    plt.ylabel('State Dimension 2')
    plt.title('State Space Mapping')
    plt.show()
1
2
3
4
5
6

问题四（电子表格法）

电子表格法（Electre Method）是一种多准则决策方法，具体步骤如下：

1. 准备准则和建筑的数据矩阵：

对于每个建筑 $i$ 和每个准则 $j$，构建一个矩阵 $C$，其中 $C_{ij}$ 表示建筑 $i$ 在准则 $j$ 上的性能值。

2. 为每个准则定义权重：

为每个准则 $j$ 分配权重 $w_j$，表示其相对重要性。确保 ${\sum }_j{w}_j=1$。

3. 定义准则之间的“优势关系”：

构建一个矩阵 $P$，其中 $P_{ij}$ 表示建筑 $i$ 在准则 $j$ 上是否优于建筑 $i^{\prime }$。可以使用以下规则定义优势关系：

• $P_{ij}=1$，如果 $C_{ij}-C_{i^{\prime }j}\ge \text{threshold}$（建筑 $i$ 在准则 $j$ 上优于建筑 $i^{\prime }$）。
• $P_{ij}=0$，如果 $|C_{ij}-C_{i^{\prime }j}|<\text{threshold}$（建筑 $i$ 和建筑 $i^{\prime }$ 在准则 $j$ 上差距较小）。
• $P_{ij}=-1$，如果 $C_{ij}-C_{i^{\prime }j}\le -\text{threshold}$（建筑 $i^{\prime }$ 在准则 $j$ 上优于建筑 $i$）。

Threshold 是一个预先定义的阈值，用于控制何时认为一个建筑在某个准则上优于另一个建筑。

4. 定义优势关系的重要性：

构建一个矩阵 $Q$，其中 $Q_{ij}$ 表示对于建筑 $i$ 在准则 $j$ 上的优势关系的重要性。通常使用三个级别的重要性：

• $Q_{ij}=2$ 表示“强优势关系”。
• $Q_{ij}=1$ 表示“中等优势关系”。
• $Q_{ij}=0$ 表示“弱优势关系”。

5. 计算优势矩阵：

构建一个优势矩阵 $S$，其中 $S_{i{i}^{\prime }}$ 表示建筑 $i$ 相对于建筑 $i^{\prime }$ 的综合优势。计算方法为：
$$S_{i{i}^{\prime }}=\sum _j{w}_j\cdot Q_{ij}\cdot P_{ij}$$

6. 聚合得分：

计算每个建筑的得分，可使用加权和或其他聚合方法：
$${\text{Score}}_i=\sum _{i^{\prime }\ne i}{S}_{i{i}^{\prime }}$$

7. 排序：

对建筑根据得分进行排序，得到最终的排名。

8. 结果解释：

解释最终的建筑排名，考虑各个准则的贡献和权重。

9. 敏感性分析：

进行敏感性分析，评估不同权重下的建筑排名和决策的稳定性。

10. 决策报告：

生成详细的决策报告，包括排名、权重、敏感性分析等信息。

import numpy as np

def electre_method(data_matrix, weights, threshold, importance_matrix):
    num_buildings, num_criteria = data_matrix.shape

    # Step 3: Define outranking relations
#见完整版

    # Step 5: Calculate outranking matrix considering importance
    weighted_outranking_matrix = outranking_matrix * importance_matrix

    # Step 6: Aggregate scores
    scores = np.sum(weighted_outranking_matrix, axis=1)

    # Step 7: Ranking
    ranking = np.argsort(scores)[::-1]

    return ranking + 1  # Adding 1 to make rankings start from 1

def calculate_outranking_relation(building_i, building_j, threshold):
    # Helper function to calculate outranking relation between two buildings
    relation = 0  # Default relation (no outranking)

    for k in range(len(building_i)):
        diff = building_i[k] - building_j[k]
        if diff >= threshold:
            relation = 1  # Building i outranks building j
            break
        elif -threshold < diff < threshold:
            relation = 0  # No outranking relation
            break
        elif diff <= -threshold:
            relation = -1  # Building j outranks building i
            break

    return relation

# Example usage:
data_matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
weights = np.array([0.3, 0.4, 0.3])
threshold = 1
importance_matrix = np.array([[2, 1, 0], [2, 1, 0], [2, 1, 0]])

ranking = electre_method(data_matrix, weights, threshold, importance_matrix)
print("Building Ranking:", ranking)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

在解决问题时，可以绘制多种图表来帮助可视化数据和结果。以下是一些可能有用的图表类型：

1. 柱状图（Bar Chart）：

   • 用于比较不同建筑在各个准则上的性能。
   • 用于显示不同准则的权重。

2. 雷达图（Radar Chart）：

   • 用于比较不同建筑在多个准则上的综合表现。
   • 每个轴代表一个准则，雷达图上的线条表示建筑在各个准则上的得分。

3. 散点图（Scatter Plot）：

   • 如果数据允许，可以用来展示两个准则之间的关系。每个点代表一个建筑，其 x 轴和 y 轴分别表示两个准则的性能值。

4. 热力图（Heatmap）：

   • 用于显示建筑之间的优势关系矩阵或权重矩阵。
   • 可以清晰地展示建筑之间的相对优势。

5. 排名图（Ranking Plot）：

   • 用于可视化建筑的排名结果。
   • 可以以柱状图或其他形式展示建筑的排名顺序。

6. 敏感性分析图（Sensitivity Analysis Plot）：

   • 如果进行了敏感性分析，可以绘制敏感性分析图，显示不同权重或阈值下的建筑排名变化情况。

更多内容可以点击下方名片详细了解，让小鹿学长带你冲刺美赛夺奖之路！
敬请期待我们的努力所做出的工作！记得关注 鹿鹿学长呀！