python经济模型，用于模拟不同政策对财富分配

用python实现的一个经济模型，用于模拟不同政策对财富分配的影响。它主要包含以下几个部分：

1. 类和初始化方法：
   • HierarchyLevel类：代表一个层级，具有层级ID、区域、资源、资产和属性。
   • Hierarchy类：代表整个层级结构，包含多个HierarchyLevel实例，以及用于模拟的方法。
2. 层级结构管理：
   • add_level：向层级结构中添加一个新的层级。
   • calculate_total_resources：计算所有层级的资源总和。
3. 经济政策模拟：
   • calculate_gini_coefficient：计算基尼系数，衡量财富分配的不平等程度。
   • apply_tax_policy：应用税收政策，根据资源数量调整层级资源。
   • inject_welfare：注入福利，为资源低于贫困线的层级提供转移支付。
   • redistribute_with_debt：进行再分配，包括债务偿还机制。
   • inherit_wealth：模拟财富继承，随机增加部分层级的资源。
4. 模拟财富分布：
   • simulate_wealth_distribution：运行模拟，根据给定的轮数、税收政策、福利配置、再分配率和继承率，调整资源分配，并跟踪基尼系数、再分配率和资产总和的变化。
5. 结果可视化：
   • visualize_risk_profile：使用Plotly Express生成基尼系数和再分配率的风险热力图。
   • multi_dimensional_analysis：使用Plotly Express生成平行坐标图，展示迭代过程中基尼系数、再分配率和资产总和的变化。
6. 模型运行和可视化：
   • 创建Hierarchy实例并运行模拟。
   • 使用模拟结果调用可视化函数。

代码细节解析

• 税收政策：根据资源数量应用不同的税率。税率根据资源量所在的区间决定。
• 福利政策：为资源低于贫困线的层级提供转移支付，转移支付额基于总资源的一定比例。
• 再分配机制：从资源最多的层级向资源最少的层级转移资源，并包含债务偿还机制，防止层级资源变为负值。
• 财富继承：随机选择部分层级，根据正态分布随机增加其资源。
• 模拟控制：通过调整再分配率来逼近目标基尼系数（0.3），模拟过程最多进行17000轮迭代。
• 可视化：使用Plotly Express生成热力图和平行坐标图，分别展示政策风险和模拟过程中的多维度数据变化。

import numpy as np
import pandas as pd
import plotly.express as px

class HierarchyLevel:
    def __init__(self, level_id, region, resources, attributes):
        self.level_id = level_id
        self.region = region  # 新增区域属性
        self.resources = resources
        self.assets = {"cash": 0, "property": 0, "equity": 0, "crypto": 0}  # 新增加密货币资产
        self.attributes = attributes

class Hierarchy:
    def __init__(self):
        self.levels = []
        self.assets_history = []

    def add_level(self, level):
        self.levels.append(level)

    def calculate_total_resources(self):
        return sum(level.resources for level in self.levels)

    def calculate_gini_coefficient(self):
        total_resources = self.calculate_total_resources()
        if total_resources == 0:
            return 0.0
        n = len(self.levels)
        average = total_resources / n
        absolute_diff_sum = sum(abs(level.resources - average) for level in self.levels)
        gini = absolute_diff_sum / (n * average)
        return gini

    def apply_tax_policy(self, tax_brackets):
        for level in self.levels:
            if level.resources > tax_brackets[0][0]:
                tax_rate = tax_brackets[min(int((level.resources - tax_brackets[0][0]) / 100), len(tax_brackets) - 1)][1]
                level.resources *= (1 - tax_rate)

    def inject_welfare(self, welfare_config):
        for level in self.levels:
            if level.resources < welfare_config['poverty_line']:
                level.resources += welfare_config['transfer_amount'] * (self.calculate_total_resources() / 100)

    def redistribute_with_debt(self, redistribution_rate):
        max_level = max(self.levels, key=lambda l: l.resources)
        min_level = min(self.levels, key=lambda l: l.resources)

        transfer_amount = max_level.resources * redistribution_rate
        if transfer_amount > max_level.resources:
            transfer_amount = max_level.resources

        max_level.resources -= transfer_amount
        min_level.resources += transfer_amount

        # 债务偿还机制
        for level in self.levels:
            if level.resources < 0:
                repayment = min(-level.resources, transfer_amount * 0.5)
                level.resources += repayment
                transfer_amount -= repayment

    def inherit_wealth(self, inheritance_rate):
        for level in self.levels:
            if np.random.rand() < inheritance_rate:
                level.resources *= (1 + np.random.normal(0, 0.1))

    def simulate_wealth_distribution(self, total_rounds=17000, tax_brackets=None, welfare_config=None, redistribution_rate=0.01, inheritance_rate=0.01):
        if tax_brackets is None:
            tax_brackets = [(0, 0.1), (1000, 0.2), (5000, 0.3)]
        if welfare_config is None:
            welfare_config = {'poverty_line': 50, 'transfer_amount': 0.5}
        if total_rounds < 100:
            raise ValueError("Simulation rounds must be >= 100")

        gini_history = []
        redistribution_rates = []
        assets_history = []

        initial_resources = [300, 90, 30, 10]
        for i in range(len(initial_resources)):
            self.add_level(HierarchyLevel(i + 1, "region", initial_resources[i], ["wealth", "savings", "assets"]))

        target_gini = 0.3
        max_iterations = total_rounds
        iteration = 0

        while iteration < max_iterations:
            self.apply_tax_policy(tax_brackets)
            self.inject_welfare(welfare_config)
            policy_effect = self.evaluate_policy(redistribution_rate)
            new_gini = self.calculate_gini_coefficient()

            gini_history.append(new_gini)
            redistribution_rates.append(redistribution_rate)

            if abs(new_gini - target_gini) <= 0.01:
                break

            if new_gini > target_gini:
                redistribution_rate = min(1, redistribution_rate + 0.001)
            else:
                redistribution_rate = max(0, redistribution_rate - 0.001)

            self.redistribute_with_debt(redistribution_rate)
            self.inherit_wealth(inheritance_rate)

            # 记录每轮迭代后的资产总和
            total_assets_per_round = sum([sum(l.assets.values()) for l in self.levels])
            assets_history.append(total_assets_per_round)

            iteration += 1

        return gini_history, redistribution_rates, assets_history

    def evaluate_policy(self, redistribution_rate):
        baseline = self.calculate_gini_coefficient()
        self.redistribute_with_debt(redistribution_rate)
        new_value = self.calculate_gini_coefficient()
        return new_value - baseline

def visualize_risk_profile(gini_history, redistribution_rates):
    df = pd.DataFrame({
        'Gini Coefficient': gini_history,
        'Redistribution Rate': redistribution_rates
    })
    fig = px.density_heatmap(df, x='Gini Coefficient', y='Redistribution Rate',
                             labels={'x': '基尼系数', 'y': '再分配率'},
                             title='政策风险热力图')
    fig.update_layout(coloraxis_colorbar=dict(title='风险等级'))
    fig.show()

def multi_dimensional_analysis(gini_history, redistribution_rates, assets_history):
    df = pd.DataFrame({
        'Iteration': range(len(gini_history)),
        'Gini': gini_history,
        'Rate': redistribution_rates,
        'Assets': assets_history  # 使用每轮迭代后的资产总和
    })
    fig = px.parallel_coordinates(df, color='Gini')
    fig.show()

# 创建模型并运行模拟
economy = Hierarchy()
gini_history, redistribution_rates, assets_history = economy.simulate_wealth_distribution(total_rounds=17000)

# 可视化
visualize_risk_profile(gini_history, redistribution_rates)
multi_dimensional_analysis(gini_history, redistribution_rates, assets_history)