下载地址：http://lanzou.com.cn/ida8e79b5

项目文件结构：

📁 output/gongjijinjisuanzhinengshengchengxitong/
├── 📄 README.md219 B
├── 📄 pom.xml1.3 KB
├── 📄 package.json730 B
├── 📄 config/application.properties689 B
├── 📄 tracing/Client.py4.5 KB
├── 📄 src/main/java/Scheduler.java6.3 KB
├── 📄 authorization/Repository.go2.5 KB
├── 📄 policies/Builder.go3.1 KB
├── 📄 config/Resolver.properties689 B
├── 📄 authorization/Server.ts3.1 KB
├── 📄 tracing/Processor.js3.2 KB
├── 📄 authorization/Adapter.py4.2 KB
├── 📄 tracing/Util.cpp1.6 KB
├── 📄 src/main/java/Service.java4.8 KB
├── 📄 src/main/java/Buffer.java4.5 KB
├── 📄 src/main/java/Observer.java6.8 KB
├── 📄 policies/Pool.ts3.3 KB
├── 📄 mock/Transformer.php4 KB
├── 📄 config/Provider.json730 B
├── 📄 policies/Dispatcher.js4.2 KB
├── 📄 authorization/Wrapper.py5.3 KB
├── 📄 tracing/Parser.js3.1 KB
├── 📄 lib/Converter.jar707 B
├── 📄 config/Worker.xml1.4 KB
├── 📄 mock/Loader.sql3.8 KB
├── 📄 STRUCTURE.txt1.4 KB

项目入口结构：

Project Structure

Folder : gongjijinjisuanzhinengshengchengxitong

Files : 26

Size : 74.7 KB

Generated: 2026-03-22 15:55:47

gongjijinjisuanzhinengshengchengxitong/
├── README.md [219 B]
├── authorization/
│ ├── Adapter.py [4.2 KB]
│ ├── Repository.go [2.5 KB]
│ ├── Server.ts [3.1 KB]
│ └── Wrapper.py [5.3 KB]
├── config/
│ ├── Provider.json [730 B]
│ ├── Resolver.properties [689 B]
│ ├── Worker.xml [1.4 KB]
│ └── application.properties [689 B]
├── lib/
│ └── Converter.jar [707 B]
├── mock/
│ ├── Loader.sql [3.8 KB]
│ └── Transformer.php [4 KB]
├── package.json [730 B]
├── policies/
│ ├── Builder.go [3.1 KB]
│ ├── Dispatcher.js [4.2 KB]
│ └── Pool.ts [3.3 KB]
├── pom.xml [1.3 KB]
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ ├── Buffer.java [4.5 KB]
│ │ │ ├── Observer.java [6.8 KB]
│ │ │ ├── Scheduler.java [6.3 KB]
│ │ │ └── Service.java [4.8 KB]
│ │ └── resources/
│ └── test/
│ └── java/
└── tracing/
├── Client.py [4.5 KB]
├── Parser.js [3.1 KB]
├── Processor.js [3.2 KB]
└── Util.cpp [1.6 KB]

Python版本的Oberon公积金智能计算核心代码，包含AI动态优化、复利预测、贷款能力评估等关键模块：

python
"""
Oberon 智能公积金AI计算引擎
核心算法模块：动态比例优化、复利预测、贷款能力评估
"""

import math
from dataclasses import dataclass
from typing import Dict, Tuple, Optional
from enum import Enum

class AIMode(Enum):
"""AI计算模式"""
SMART = "smart" # 智能均衡
AGGRESSIVE = "aggressive" # 最大化累计
CONSERVATIVE = "conservative" # 稳健流动性

@dataclass
class CityPolicy:
"""城市公积金政策"""
min_rate: float = 5.0 # 最低缴存比例 (%)
max_rate: float = 12.0 # 最高缴存比例 (%)
loan_multiplier: float = 12.0 # 贷款倍数
base_ceiling: float = 50000 # 基数上限
base_floor: float = 2300 # 基数下限
interest_rate: float = 0.015 # 年利率 (1.5%)

@dataclass
class CalculationResult:
"""计算结果"""

# 基础数据
base_salary: float
employer_rate: float
employee_rate: float

# 月缴存额
employer_month: float
employee_month: float
total_month: float
total_year: float

# 综合比例
total_ratio: float

# AI预测
forecast_1y: float      # 1年后账户余额
forecast_3y: float      # 3年后账户余额
loan_ability: float     # 预估可贷额度
confidence: float       # 置信指数 (%)

# 建议
ai_advice: str
optimization_tip: str

class OberonProvidentFundAI:
"""
Oberon 公积金智能计算引擎
基于动态缴存模型 + 机器学习启发式算法
"""

def __init__(self, city_policy: Optional[CityPolicy] = None):
    """
    初始化引擎
    :param city_policy: 城市政策配置，默认使用通用配置
    """
    self.policy = city_policy or CityPolicy()

def optimize_rates(
    self,
    base_salary: float,
    current_employer_rate: float,
    current_employee_rate: float,
    last_balance: float,
    mode: AIMode = AIMode.SMART
) -> Tuple[float, float, str]:
    """
    AI优化缴存比例
    根据用户收入、账户余额和策略模式，智能推荐最佳缴存比例

    :param base_salary: 月缴存基数
    :param current_employer_rate: 当前单位比例
    :param current_employee_rate: 当前个人比例
    :param last_balance: 上年账户余额
    :param mode: AI计算模式
    :return: (优化后单位比例, 优化后个人比例, 建议说明)
    """
    min_rate = self.policy.min_rate
    max_rate = self.policy.max_rate

    # 收入系数：月薪越高，可承受缴存能力越强
    income_factor = min(1.2, max(0.6, base_salary / 25000))

    if mode == AIMode.AGGRESSIVE:
        # 激进模式：顶格缴存，最大化积累
        employer_rate = max_rate
        employee_rate = max_rate
        advice = "🏁 激进策略：推荐顶格缴存，加速账户积累，提升未来贷款能力"

    elif mode == AIMode.CONSERVATIVE:
        # 稳健模式：降低缴存，提高到手现金
        suggested = max(min_rate, min(7.0, (min_rate + max_rate) / 2 - 1))
        employer_rate = suggested
        employee_rate = suggested
        advice = "🛡️ 稳健策略：侧重流动性，降低缴存比例，提高实发工资"

    else:  # SMART 智能均衡模式
        # 基于余额的分段决策
        if last_balance < 20000:
            # 余额不足，适度提高积累
            target = min(max_rate, 9.0)
            advice = "🧠 智能均衡：当前余额偏低，适度提高缴存比例，加快资产积累"
        elif last_balance > 80000:
            # 余额充裕，优化现金流
            target = max(min_rate, 6.5)
            advice = "🧠 智能均衡：余额较充裕，略微调低缴存优化现金流，同时保证复利"
        else:
            # 中等余额，采用城市基准中间值
            target = (min_rate + max_rate) / 2
            advice = "🧠 智能均衡：根据城市基准与余额水平，维持标准缴存方案"

        # 收入因子微调
        if income_factor > 0.9 and target < max_rate:
            target = min(max_rate, target + 0.5)

        target = min(max_rate, max(min_rate, target))
        employer_rate = round(target, 1)
        employee_rate = round(target, 1)

    # 边界约束
    employer_rate = min(max_rate, max(min_rate, employer_rate))
    employee_rate = min(max_rate, max(min_rate, employee_rate))

    return employer_rate, employee_rate, advice

def calculate(
    self,
    base_salary: float,
    employer_rate: float,
    employee_rate: float,
    last_balance: float,
    mode: AIMode = AIMode.SMART,
    apply_ai_optimization: bool = True
) -> CalculationResult:
    """
    执行公积金计算

    :param base_salary: 月缴存基数
    :param employer_rate: 单位缴存比例 (%)
    :param employee_rate: 个人缴存比例 (%)
    :param last_balance: 上年账户余额
    :param mode: AI模式（用于优化建议）
    :param apply_ai_optimization: 是否应用AI比例优化
    :return: 计算结果
    """
    # AI比例优化（如启用）
    if apply_ai_optimization:
        employer_rate, employee_rate, ai_advice = self.optimize_rates(
            base_salary, employer_rate, employee_rate, last_balance, mode
        )
    else:
        ai_advice = "未启用AI优化，使用用户自定义比例"

    # 基础缴存计算
    employer_month = base_salary * (employer_rate / 100)
    employee_month = base_salary * (employee_rate / 100)
    total_month = employer_month + employee_month
    total_year = total_month * 12
    total_ratio = employer_rate + employee_rate

    # 复利预测模型
    annual_interest = self.policy.interest_rate

    # 1年后余额预测
    forecast_1y = last_balance * (1 + annual_interest) + total_year

    # 3年后余额预测（连续复利）
    balance = last_balance
    for _ in range(3):
        balance = balance * (1 + annual_interest) + total_year
    forecast_3y = balance

    # 贷款能力评估
    # 基础倍数 × 余额 × 模式系数
    mode_factor = 1.1 if mode == AIMode.AGGRESSIVE else (0.95 if mode == AIMode.CONSERVATIVE else 1.0)
    raw_loan = forecast_1y * self.policy.loan_multiplier * mode_factor

    # 上限约束：不超过年薪的8倍
    annual_salary = base_salary * 12
    loan_ability = min(raw_loan, annual_salary * 8)

    # 置信指数计算
    confidence = 85.0
    if employer_rate == employee_rate:
        confidence += 5  # 比例一致加分
    if last_balance > 0:
        confidence += 3
    if base_salary <= self.policy.base_ceiling:
        confidence += 2
    confidence = min(99.0, max(70.0, confidence))

    # 生成优化建议
    optimization_tip = self._generate_tips(
        forecast_3y, loan_ability, total_year, last_balance, mode
    )

    return CalculationResult(
        base_salary=base_salary,
        employer_rate=employer_rate,
        employee_rate=employee_rate,
        employer_month=employer_month,
        employee_month=employee_month,
        total_month=total_month,
        total_year=total_year,
        total_ratio=total_ratio,
        forecast_1y=forecast_1y,
        forecast_3y=forecast_3y,
        loan_ability=loan_ability,
        confidence=confidence,
        ai_advice=ai_advice,
        optimization_tip=optimization_tip
    )

def _generate_tips(
    self,
    forecast_3y: float,
    loan_ability: float,
    annual_contribution: float,
    current_balance: float,
    mode: AIMode
) -> str:
    """生成个性化优化建议"""
    tips = []

    # 贷款能力评估
    if loan_ability < 150000:
        tips.append("📉 预估贷款额度偏低，建议提高缴存比例或延长缴存时间")
    elif loan_ability > 500000:
        tips.append("🏡 公积金贷款潜力充足，可覆盖大部分刚需住房需求")
    else:
        tips.append("⚖️ 当前公积金方案均衡，如需更高额度可切换至激进模式")

    # 增值效率评估
    if current_balance > 0 and annual_contribution > 0:
        growth_rate = (annual_contribution + current_balance * 0.015) / current_balance * 100
        if growth_rate > 30:
            tips.append(f"📈 账户年增值率{growth_rate:.1f}%，资产积累效率良好")
        elif growth_rate < 15:
            tips.append(f"⚠️ 账户增值率{growth_rate:.1f}%偏低，可考虑提高缴存")

    # 模式专属建议
    if mode == AIMode.AGGRESSIVE:
        tips.append("⚡ 当前采用激进模式，长期收益最大化，适合有购房计划的用户")
    elif mode == AIMode.CONSERVATIVE:
        tips.append("💧 稳健模式优先保障现金流，适合短期资金需求较高的用户")
    else:
        tips.append("🎯 智能均衡模式已综合优化收益与流动性")

    return " ".join(tips)

def batch_simulation(
    self,
    base_salary: float,
    last_balance: float,
    mode: AIMode = AIMode.SMART
) -> Dict[float, Dict]:
    """
    批量模拟不同缴存比例的效果
    用于敏感性分析，帮助用户决策

    :param base_salary: 月缴存基数
    :param last_balance: 上年余额
    :param mode: AI模式
    :return: 不同比例下的结果字典
    """
    results = {}
    min_rate = self.policy.min_rate
    max_rate = self.policy.max_rate

    for rate in range(int(min_rate * 2), int(max_rate * 2) + 1, 2):
        rate_val = rate / 2  # 步长0.5%
        result = self.calculate(
            base_salary=base_salary,
            employer_rate=rate_val,
            employee_rate=rate_val,
            last_balance=last_balance,
            mode=mode,
            apply_ai_optimization=False  # 批量模拟时禁用自动优化
        )
        results[rate_val] = {
            "total_month": result.total_month,
            "forecast_3y": result.forecast_3y,
            "loan_ability": result.loan_ability
        }

    return results

============= 使用示例 =============

if name == "main":

# 初始化Oberon引擎
engine = OberonProvidentFundAI()

# 示例1: 智能均衡模式计算
print("=" * 50)
print("示例1: 智能均衡模式")
print("=" * 50)

result = engine.calculate(
    base_salary=12500,
    employer_rate=7.0,
    employee_rate=7.0,
    last_balance=28500,
    mode=AIMode.SMART
)

print(f"缴存基数: ¥{result.base_salary:,.0f}")
print(f"单位比例: {result.employer_rate}% | 个人比例: {result.employee_rate}%")
print(f"月缴存总额: ¥{result.total_month:,.0f}")
print(f"年归集额: ¥{result.total_year:,.0f}")
print(f"1年预估余额: ¥{result.forecast_1y:,.0f}")
print(f"3年复利累积: ¥{result.forecast_3y:,.0f}")
print(f"预估可贷额度: ¥{result.loan_ability:,.0f}")
print(f"置信指数: {result.confidence}%")
print(f"AI建议: {result.ai_advice}")
print(f"优化提示: {result.optimization_tip}")

print("\n" + "=" * 50)
print("示例2: 激进模式对比")
print("=" * 50)

result_agg = engine.calculate(
    base_salary=12500,
    employer_rate=7.0,
    employee_rate=7.0,
    last_balance=28500,
    mode=AIMode.AGGRESSIVE
)

print(f"激进模式 - 单位比例: {result_agg.employer_rate}%")
print(f"激进模式 - 3年累积: ¥{result_agg.forecast_3y:,.0f}")
print(f"激进模式 - 可贷额度: ¥{result_agg.loan_ability:,.0f}")
print(f"与智能模式差额: ¥{result_agg.forecast_3y - result.forecast_3y:,.0f}")

print("\n" + "=" * 50)
print("示例3: 批量模拟 (比例敏感性分析)")
print("=" * 50)

simulations = engine.batch_simulation(
    base_salary=12500,
    last_balance=28500,
    mode=AIMode.SMART
)

print("缴存比例 | 月缴存额 | 3年累积 | 可贷额度")
print("-" * 50)
for rate, data in simulations.items():
    print(f"  {rate:4.1f}%   | ¥{data['total_month']:>6,.0f} | ¥{data['forecast_3y']:>9,.0f} | ¥{data['loan_ability']:>9,.0f}")