diff --git a/app/api/v1/calculation/__init__.py b/app/api/v1/calculation/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/app/api/v1/calculation/calcuation.py b/app/api/v1/calculation/calcuation.py new file mode 100644 index 0000000..5d03a7c --- /dev/null +++ b/app/api/v1/calculation/calcuation.py @@ -0,0 +1,120 @@ +from fastapi import APIRouter, Depends, HTTPException, status +from typing import Optional, List, Dict, Any +import json + +from app.controllers.user_valuation import user_valuation_controller +from app.schemas.valuation import ( + UserValuationCreate, + UserValuationQuery, + UserValuationList, + UserValuationOut, + UserValuationDetail +) +from app.schemas.base import Success, SuccessExtra +from app.utils.app_user_jwt import get_current_app_user_id +from app.utils.calculation_engine.economic_value_b1.economic_value_b1 import EconomicValueB1Calculator + +app_valuations_router = APIRouter(tags=["用户端估值评估"]) + +@app_valuations_router.post("/calculation", summary="计算估值") +async def calculate_valuation( + data: UserValuationCreate, + user_id: int = Depends(get_current_app_user_id) +): + """ + 计算估值评估 + + 根据用户提交的估值评估数据，调用计算引擎进行经济价值B1计算 + """ + try: + # 创建计算器实例 + calculator = EconomicValueB1Calculator() + + # 从用户数据中提取计算所需的参数 + input_data = _extract_calculation_params(data) + + # 调用计算引擎进行估值计算 + calculation_result = calculator.calculate_complete_economic_value_b1(input_data) + + # 创建估值评估记录 + result = await user_valuation_controller.create_valuation( + user_id=user_id, + data=data + ) + + # 将计算结果添加到返回数据中 + result_dict = json.loads(result.model_dump_json()) + result_dict['calculation_result'] = calculation_result + + return Success(data=result_dict, msg="估值计算完成") + + except Exception as e: + raise HTTPException(status_code=400, detail=f"计算失败: {str(e)}") + + +def _extract_calculation_params(data: UserValuationCreate) -> Dict[str, Any]: + """ + 从用户提交的数据中提取计算所需的参数 + + Args: + data: 用户提交的估值评估数据 + + Returns: + Dict: 计算所需的参数字典 + """ + # 基础价值B11相关参数 + # 财务价值所需数据 从近三年收益计算 + three_year_income = data.three_year_income or [0, 0, 0] + + + # 法律强度L相关参数 - 需要用户额外提供评分 + # 这里使用默认值，实际应用中需要用户填写 + patent_score = 5.0 # 专利分 (0-10分) + popularity_score = 5.0 # 普及地域分 (0-10分) + infringement_score = 5.0 # 侵权分 (0-10分) + + # 发展潜力D相关参数 + esg_score = 5.0 # ESG分 (0-10分) + # 创新投入比 = (研发费用/营收) * 100 + try: + rd_investment = float(data.rd_investment or 0) + annual_revenue = float(data.annual_revenue or 1) # 避免除零 + innovation_ratio = (rd_investment / annual_revenue) * 100 if annual_revenue > 0 else 0 + except (ValueError, TypeError): + innovation_ratio = 0.0 + + # 行业系数I - 系统配置值 + target_industry_roe = 0.15 # 目标行业平均ROE + benchmark_industry_roe = 0.12 # 基准行业ROE + + # 流量因子B12相关参数 + # 近30天搜索指数S1 - 从社交媒体数据计算 + search_index_s1 = 4500.0 # 默认值，实际应从API获取 + industry_average_s2 = 5000.0 # 行业均值，系统配置 + + # 社交媒体传播度S3 - 从线上账号信息计算 + social_media_spread_s3 = 1.07 # 默认值，实际应从API获取 + + # 政策乘数B13相关参数 + # 政策契合度评分P - 根据行业和资助情况计算 + policy_compatibility_score = 9.1 # 默认值，实际应系统计算 + + return { + # 基础价值B11相关参数 + 'financial_value': financial_value, + 'patent_score': patent_score, + 'popularity_score': popularity_score, + 'infringement_score': infringement_score, + 'esg_score': esg_score, + 'innovation_ratio': innovation_ratio, + 'target_industry_roe': target_industry_roe, + 'benchmark_industry_roe': benchmark_industry_roe, + + # 流量因子B12相关参数 + 'search_index_s1': search_index_s1, + 'industry_average_s2': industry_average_s2, + 'social_media_spread_s3': social_media_spread_s3, + + # 政策乘数B13相关参数 + 'policy_compatibility_score': policy_compatibility_score + } \ No newline at end of file diff --git a/app/utils/calculation_engine/__init__.py b/app/utils/calculation_engine/__init__.py new file mode 100644 index 0000000..f1d96c9 --- /dev/null +++ b/app/utils/calculation_engine/__init__.py @@ -0,0 +1,3 @@ +''' +这是非物质文化遗产IP知识产权评估系统的核心计算引擎包。 +''' diff --git a/app/utils/calculation_engine/economic_value_b1/__init__.py b/app/utils/calculation_engine/economic_value_b1/__init__.py new file mode 100644 index 0000000..47c3faa --- /dev/null +++ b/app/utils/calculation_engine/economic_value_b1/__init__.py @@ -0,0 +1,18 @@ +""" +经济价值B1计算包 +经济价值B1 = 基础价值B11 × (1 + 流量因子B12) × 政策乘数B13 +""" + +from .economic_value_b1 import EconomicValueB1Calculator +from .sub_formulas import ( + BasicValueB11Calculator, + TrafficFactorB12Calculator, + PolicyMultiplierB13Calculator +) + +__all__ = [ + "EconomicValueB1Calculator", + "BasicValueB11Calculator", + "TrafficFactorB12Calculator", + "PolicyMultiplierB13Calculator" +] \ No newline at end of file diff --git a/app/utils/calculation_engine/economic_value_b1/economic_value_b1.py b/app/utils/calculation_engine/economic_value_b1/economic_value_b1.py new file mode 100644 index 0000000..e263163 --- /dev/null +++ b/app/utils/calculation_engine/economic_value_b1/economic_value_b1.py @@ -0,0 +1,142 @@ +""" +经济价值B1计算模块 + +经济价值B1 = 基础价值B11 × (1 + 流量因子B12) × 政策乘数B13 + +""" + +from typing import Dict +try: + # 相对导入（当作为包使用时） + from .sub_formulas.basic_value_b11 import BasicValueB11Calculator + from .sub_formulas.traffic_factor_b12 import TrafficFactorB12Calculator + from .sub_formulas.policy_multiplier_b13 import PolicyMultiplierB13Calculator +except ImportError: + # 绝对导入（当直接运行时） + from sub_formulas.basic_value_b11 import BasicValueB11Calculator + from sub_formulas.traffic_factor_b12 import TrafficFactorB12Calculator + from sub_formulas.policy_multiplier_b13 import PolicyMultiplierB13Calculator + + +class EconomicValueB1Calculator: + """经济价值B1计算器""" + + def __init__(self): + """初始化计算器""" + self.basic_value_calculator = BasicValueB11Calculator() + self.traffic_factor_calculator = TrafficFactorB12Calculator() + self.policy_multiplier_calculator = PolicyMultiplierB13Calculator() + + def calculate_economic_value_b1(self, + basic_value_b11: float, + traffic_factor_b12: float, + policy_multiplier_b13: float) -> float: + """ + 计算经济价值B1 + + + 经济价值B1 = 基础价值B11 × (1 + 流量因子B12) × 政策乘数B13 + + Args: + basic_value_b11: 基础价值B11 (系统计算) + traffic_factor_b12: 流量因子B12 (系统计算) + policy_multiplier_b13: 政策乘数B13 (系统计算) + + Returns: + float: 经济价值B1 + """ + economic_value = basic_value_b11 * (1 + traffic_factor_b12) * policy_multiplier_b13 + + return economic_value + + def calculate_complete_economic_value_b1(self, input_data: Dict) -> Dict: + """ + 计算完整的经济价值B1，包含所有子公式 + + Args: + input_data: 输入数据字典，包含所有必要的参数 + + Returns: + Dict: 包含所有中间计算结果和最终结果的字典 + """ + # 财务价值F 近三年年均收益列表 [1,2,3] + + financial_value = self.basic_value_calculator.calculate_financial_value_f() + # 计算法律强度L patent_score: 专利分 (0-10分) (用户填写) + # popularity_score: 普及地域分 (0-10分) (用户填写) + # infringement_score: 侵权分 (0-10分) (用户填写) + + legal_strength = self.basic_value_calculator.calculate_legal_strength_l() + # 发展潜力 patent_score: 专利分 (0-10分) (用户填写) + # esg_score: ESG分 (0-10分) (用户填写) + # innovation_ratio: 创新投入比 (研发费用/营收) * 100 (用户填写) + + development_potential = self.basic_value_calculator.calculate_development_potential_d() + # 计算行业系数I target_industry_roe: 目标行业平均ROE (系统配置) + # benchmark_industry_roe: 基准行业ROE (系统配置) + industry_coefficient = self.basic_value_calculator.calculate_industry_coefficient_i() + # 计算基础价值B11 + basic_value_b11 = self.basic_value_calculator.calculate_basic_value_b11( + financial_value, + legal_strength, + development_potential, + industry_coefficient + ) + + # 计算流量因子B12 + traffic_factor_b12 = self.traffic_factor_calculator.calculate_traffic_factor_b12( + input_data['search_index_s1'], + input_data['industry_average_s2'], + input_data['social_media_spread_s3'] + ) + + # 计算政策乘数B13 + policy_multiplier_b13 = self.policy_multiplier_calculator.calculate_policy_multiplier_b13( + input_data['policy_compatibility_score'] + ) + + # 计算经济价值B1 + economic_value_b1 = self.calculate_economic_value_b1( + basic_value_b11, + traffic_factor_b12, + policy_multiplier_b13 + ) + + return { + 'basic_value_b11': basic_value_b11, + 'traffic_factor_b12': traffic_factor_b12, + 'policy_multiplier_b13': policy_multiplier_b13, + 'economic_value_b1': economic_value_b1 + } + + +# 示例使用 +if __name__ == "__main__": + + calculator = EconomicValueB1Calculator() + + # 示例数据 + input_data = { + # 基础价值B11相关参数 + 'financial_value': 68.04, # 财务价值F + 'legal_strength': 7.90, # 法律强度L + 'development_potential': 6.00, # 发展潜力D + 'industry_coefficient': 0.25, # 行业系数I + + # 流量因子B12相关参数 + 'search_index_s1': 4500.0, # 近30天搜索指数S1 + 'industry_average_s2': 5000.0, # 行业均值S2 + 'social_media_spread_s3': 1.07, # 社交媒体传播度S3 + + # 政策乘数B13相关参数 + 'policy_compatibility_score': 9.1 # 政策契合度评分P + } + + # 计算经济价值B1 + result = calculator.calculate_complete_economic_value_b1(input_data) + + print("经济价值B1计算结果:") + print(f"基础价值B11: {result['basic_value_b11']:.2f}") + print(f"流量因子B12: {result['traffic_factor_b12']:.4f}") + print(f"政策乘数B13: {result['policy_multiplier_b13']:.4f}") + print(f"经济价值B1: {result['economic_value_b1']:.2f}") diff --git a/app/utils/calculation_engine/economic_value_b1/sub_formulas/__init__.py b/app/utils/calculation_engine/economic_value_b1/sub_formulas/__init__.py new file mode 100644 index 0000000..5c17737 --- /dev/null +++ b/app/utils/calculation_engine/economic_value_b1/sub_formulas/__init__.py @@ -0,0 +1,34 @@ +""" +经济价值B1子公式包 + +包含经济价值B1的所有子公式计算模块： + +1. basic_value_b11: 基础价值B11计算 + - 财务价值F = [3年内年均收益 × (1 + 增长率)^5] / 5 + - 法律强度L = 专利分 × 0.4 + 普及分 × 0.3 + 侵权分 × 0.3 + - 发展潜力D = 专利分 × 0.5 + ESG分 × 0.2 + 创新投入比 × 0.3 + - 行业系数I = (目标行业平均ROE - 基准行业ROE) / 基准行业ROE + + - 基础价值B11 = 财务价值F × (0.45 + 0.05 × 行业系数I) + 法律强度L × (0.35 + 0.05 × 行业系数I) + 发展潜力D × 0.2 + +2. traffic_factor_b12: 流量因子B12计算 + - 近30天搜索指数S1 = 百度搜索指数 × 0.4 + 微信搜索指数 × 0.3 + 微博搜索指数 × 0.3 + - 社交媒体传播度S3 = 互动量指数 × 0.4 + 覆盖人群指数 × 0.3 + 转化效率 × 0.3 + - 行业均值S2 = 系统内根据行业自动匹配行业均值S2 + + - 流量因子B12 = ln(近30天搜索指数S1/行业均值S2) × 0.3 + 社交媒体传播度S3 × 0.7 + +3. policy_multiplier_b13: 政策乘数B13计算 + - 政策契合度P = 政策匹配度 × 0.4 + 实施阶段评分 × 0.3 + 资金支持度 × 0.3 + - 政策乘数B13 = 1 + (政策契合度评分P × 0.15) +""" + +from .basic_value_b11 import BasicValueB11Calculator +from .traffic_factor_b12 import TrafficFactorB12Calculator +from .policy_multiplier_b13 import PolicyMultiplierB13Calculator + +__all__ = [ + "BasicValueB11Calculator", + "TrafficFactorB12Calculator", + "PolicyMultiplierB13Calculator" +] diff --git a/app/utils/calculation_engine/economic_value_b1/sub_formulas/basic_value_b11.py b/app/utils/calculation_engine/economic_value_b1/sub_formulas/basic_value_b11.py new file mode 100644 index 0000000..72d427a --- /dev/null +++ b/app/utils/calculation_engine/economic_value_b1/sub_formulas/basic_value_b11.py @@ -0,0 +1,296 @@ +import math +from typing import List, Optional + + +class BasicValueB11Calculator: + """基础价值B11计算器""" + + def __init__(self): + """初始化计算器""" + pass + + def calculate_basic_value_b11(self, + financial_value: float, + legal_strength: float, + development_potential: float, + industry_coefficient: float) -> float: + """ + 计算基础价值B11 + + 基础价值B11 = 财务价值F × (0.45 + 0.05 × 行业系数I) + 法律强度L × (0.35 + 0.05 × 行业系数I) + 发展潜力D × 0.2 + + Args: + financial_value: 财务价值F (用户填写) + legal_strength: 法律强度L (用户填写) + development_potential: 发展潜力D (用户填写) + industry_coefficient: 行业系数I (系统配置) + + Returns: + float: 基础价值B11 + """ + basic_value = (financial_value * (0.45 + 0.05 * industry_coefficient) + + legal_strength * (0.35 + 0.05 * industry_coefficient) + + development_potential * 0.2) + + return basic_value + + def growth_rate(self, annual_revenue_3_years: List[float]): + """ + + """ + g1, g2 = (annual_revenue_3_years[1] - annual_revenue_3_years[0]) / annual_revenue_3_years[0] * 100, ( + annual_revenue_3_years[2] - annual_revenue_3_years[1]) / annual_revenue_3_years[1] * 100 + predicted_growth = g2 + (g2 - g1) + return predicted_growth + + def calculate_financial_value_f(self, + annual_revenue_3_years: List[float], + growth_rate: Optional[float] = None) -> float: + """ + 计算财务价值F + + 财务价值F = [3年内年均收益 × (1 + 增长率)^5] / 5 + + Args: + annual_revenue_3_years: 近三年年均收益列表，单位：万元 (用户填写) + growth_rate: 增长率，如果为None则自动计算 (用户填写) + + Returns: + float: 财务价值F + """ + if len(annual_revenue_3_years) != 3: + raise ValueError("必须提供近三年的收益数据") + + # 计算年均收益 + avg_annual_revenue = sum(annual_revenue_3_years) / 3 + + # 如果没有提供增长率，则根据三年数据计算 + if growth_rate is None: + growth_rate = self._calculate_growth_rate(annual_revenue_3_years) + + financial_value = (avg_annual_revenue * math.pow(1 + growth_rate, 5)) / 5 + + return financial_value + + def _calculate_growth_rate(self, revenue_data: List[float]) -> float: + """ + 根据三年收益数据计算增长率 + + Args: + revenue_data: 三年收益数据 (用户填写) + + Returns: + float: 增长率 + """ + if len(revenue_data) != 3: + raise ValueError("必须提供三年的收益数据") + + # 计算两个增长率差值作为预测的增长率差值 + growth_rate_1 = (revenue_data[1] - revenue_data[0]) / revenue_data[0] if revenue_data[0] != 0 else 0 + growth_rate_2 = (revenue_data[2] - revenue_data[1]) / revenue_data[1] if revenue_data[1] != 0 else 0 + + # 使用两个增长率的平均值 + avg_growth_rate = (growth_rate_1 + growth_rate_2) / 2 + + return avg_growth_rate + + def calculate_legal_strength_l(self, + patent_score: float, + popularity_score: float, + infringement_score: float) -> float: + """ + 计算法律强度L + + + 法律强度L = 专利分 × 0.4 + 普及分 × 0.3 + 侵权分 × 0.3 + + Args: + patent_score: 专利分 (0-10分) (用户填写) + popularity_score: 普及地域分 (0-10分) (用户填写) + infringement_score: 侵权分 (0-10分) (用户填写) + + Returns: + float: 法律强度L + """ + + legal_strength = (patent_score * 0.4 + + popularity_score * 0.3 + + infringement_score * 0.3) + + return legal_strength + + def calculate_development_potential_d(self, + patent_score: float, + esg_score: float, + innovation_ratio: float) -> float: + """ + 计算发展潜力D + + + 发展潜力D = 专利分 × 0.5 + ESG分 × 0.2 + 创新投入比 × 0.3 + + Args: + patent_score: 专利分 (0-10分) (用户填写) + esg_score: ESG分 (0-10分) (用户填写) + innovation_ratio: 创新投入比 (研发费用/营收) * 100 (用户填写) + + Returns: + float: 发展潜力D + """ + + development_potential = (patent_score * 0.5 + + esg_score * 0.2 + + innovation_ratio * 0.3) + + return development_potential + + def calculate_industry_coefficient_i(self, + target_industry_roe: float, + benchmark_industry_roe: float) -> float: + """ + 计算行业系数I + + 行业系数I = (目标行业平均ROE - 基准行业ROE) / 基准行业ROE + + Args: + target_industry_roe: 目标行业平均ROE (系统配置) + benchmark_industry_roe: 基准行业ROE (系统配置) + + Returns: + float: 行业系数I + """ + if benchmark_industry_roe == 0: + raise ValueError("基准行业ROE不能为0") + + industry_coefficient = (target_industry_roe - benchmark_industry_roe) / benchmark_industry_roe + + return industry_coefficient + + +# 专利相关计算函数 +def calculate_patent_score(patent_remaining_years: int) -> float: + """ + 计算专利分 + + 专利剩余保护期评分标准： + - >10年: 10分 + - 5-10年: 7分 + - <5年: 3分 + + Args: + patent_remaining_years: 专利剩余保护期（年） (用户填写) + + Returns: + float: 专利分 + """ + if patent_remaining_years > 10: + return 10.0 + elif patent_remaining_years >= 5: + return 7.0 + else: + return 3.0 + + +# 识别用户所上传的图像中的专利号，通过API验证专利是否存在，按所用专利数量赋分，未引用0分，每引用一项+2.5分，10分封顶（0-10分） +def calculate_patent_usage_score(patent_count: int) -> float: + """ + 计算专利使用量分 + + 专利使用量评分标准： + - 未引用: 0分 + - 每引用一项: +2.5分 + - 10分封顶 + + Args: + patent_count: 专利数量 (用户填写) + + Returns: + float: 专利使用量分 + """ + score = min(patent_count * 2.5, 10.0) + return score + + +# 普及地域评分 +def calculate_popularity_score(region_coverage: str) -> float: + """ + 计算普及地域分 + + 全球覆盖(10分)，全国覆盖(7分)，区域覆盖(4分) + + Args: + region_coverage: 普及地域类型 (用户填写) + + Returns: + float: 普及地域分 + """ + coverage_scores = { + "全球覆盖": 10.0, + "全国覆盖": 7.0, + "区域覆盖": 4.0 + } + + return coverage_scores.get(region_coverage, 0.0) + + +# 侵权记录评分 +def calculate_infringement_score(infringement_status: str) -> float: + """ + 计算侵权记录分 + + 无侵权记录(10分)，历史侵权已解决(6分)，现存纠纷(2分) + + Args: + infringement_status: 侵权记录状态 (用户填写) + + Returns: + float: 侵权记录分 + """ + infringement_scores = { + "无侵权记录": 10.0, + "历史侵权已解决": 6.0, + "现存纠纷": 2.0 + } + + return infringement_scores.get(infringement_status, 0.0) + + +# 示例使用 +if __name__ == "__main__": + # 创建计算器实例 + calculator = BasicValueB11Calculator() + + # 示例数据 + annual_revenue = [100, 120, 150] # 近三年收益，单位：万元 (用户填写) + patent_remaining_years = 8 # 专利剩余年限 (用户填写) + region_coverage = "全国覆盖" # 普及地域 (用户填写) + infringement_status = "无侵权记录" # 侵权记录 (用户填写) + patent_count = 2 # 专利数量 (用户填写) + esg_score = 10.0 # ESG分 (用户填写) + innovation_ratio = 5.0 # 创新投入比 (用户填写) 创新投入比（研发费用/营收）*100 + target_industry_roe = 0.15 # 目标行业ROE (系统配置) + benchmark_industry_roe = 0.12 # 基准行业ROE (系统配置) + + # 计算各项指标 + financial_value = calculator.calculate_financial_value_f(annual_revenue) + patent_score = calculate_patent_score(patent_remaining_years) + popularity_score = calculate_popularity_score(region_coverage) + infringement_score = calculate_infringement_score(infringement_status) + legal_strength = calculator.calculate_legal_strength_l(patent_score, popularity_score, infringement_score) + + patent_usage_score = calculate_patent_usage_score(patent_count) + development_potential = calculator.calculate_development_potential_d(patent_usage_score, esg_score, + innovation_ratio) + + industry_coefficient = calculator.calculate_industry_coefficient_i(target_industry_roe, benchmark_industry_roe) + + # 计算基础价值B11 + basic_value = calculator.calculate_basic_value_b11( + financial_value, legal_strength, development_potential, industry_coefficient + ) + + print(f"财务价值F: {financial_value:.2f}") + print(f"法律强度L: {legal_strength:.2f}") + print(f"发展潜力D: {development_potential:.2f}") + print(f"行业系数I: {industry_coefficient:.4f}") + print(f"基础价值B11: {basic_value:.2f}") diff --git a/app/utils/calculation_engine/economic_value_b1/sub_formulas/policy_multiplier_b13.py b/app/utils/calculation_engine/economic_value_b1/sub_formulas/policy_multiplier_b13.py new file mode 100644 index 0000000..78c4f5f --- /dev/null +++ b/app/utils/calculation_engine/economic_value_b1/sub_formulas/policy_multiplier_b13.py @@ -0,0 +1,134 @@ +class PolicyMultiplierB13Calculator: + """政策乘数B13计算器""" + + def __init__(self): + """初始化计算器""" + pass + + def calculate_policy_multiplier_b13(self, policy_compatibility_score: float) -> float: + """ + 计算政策乘数B13 + + + 政策乘数B13 = 1 + (政策契合度评分P × 0.15) + + Args: + policy_compatibility_score: 政策契合度评分P (系统计算) + + Returns: + float: 政策乘数B13 + """ + # + policy_multiplier = 1 + (policy_compatibility_score * 0.15) + + return policy_multiplier + + def calculate_policy_compatibility_score(self, + policy_match_score: float, + implementation_stage_score: float, + funding_support_score: float) -> float: + """ + 计算政策契合度评分P + + + 政策契合度P = 政策匹配度 × 0.4 + 实施阶段评分 × 0.3 + 资金支持度 × 0.3 + + Args: + policy_match_score: 政策匹配度 (系统配置) + implementation_stage_score: 实施阶段评分 (用户填写) + funding_support_score: 资金支持度 (用户填写) + + Returns: + float: 政策契合度评分P + """ + # + policy_compatibility = (policy_match_score * 0.4 + + implementation_stage_score * 0.3 + + funding_support_score * 0.3) + + return policy_compatibility + + def calculate_policy_match_score(self, industry: str) -> float: + """ + 计算政策匹配度 + + 系统内根据行业自动匹配政策匹配度 + + Args: + industry: 所属行业 (用户填写) + + Returns: + float: 政策匹配度 + """ + + return 5 + + def calculate_implementation_stage_score(self, implementation_stage: str) -> float: + """ + 计算实施阶段评分 + + 用户选择目前资产的实施阶段，成熟应用(10分)、推广阶段(7分)、试点阶段(4分) + + Args: + implementation_stage: 实施阶段 (用户填写) + + Returns: + float: 实施阶段评分 + """ + stage_scores = { + "成熟应用": 10.0, + "推广阶段": 7.0, + "试点阶段": 4.0 + } + + return stage_scores.get(implementation_stage, 0.0) + + def calculate_funding_support_score(self, funding_support: str) -> float: + """ + 计算资金支持度 + + 用户选择目前资产的资金支持情况，国家级资助(10分)、省级资助(7分)、无资助(0分) + + Args: + funding_support: 资金支持情况 (用户填写) + + Returns: + float: 资金支持度 + """ + funding_scores = { + "国家级资助": 10.0, + "省级资助": 7.0, + "无资助": 0.0 + } + + return funding_scores.get(funding_support, 0.0) + + +# 示例使用 +if __name__ == "__main__": + # 创建计算器实例 + calculator = PolicyMultiplierB13Calculator() + + # 示例数据 + industry = "文化艺术" # 所属行业 (用户填写) + implementation_stage = "成熟应用" # 实施阶段 (用户填写) + funding_support = "国家级资助" # 资金支持 (用户填写) + + # 计算各项指标 + policy_match_score = calculator.calculate_policy_match_score(industry) + implementation_stage_score = calculator.calculate_implementation_stage_score(implementation_stage) + funding_support_score = calculator.calculate_funding_support_score(funding_support) + + # 计算政策契合度评分P + policy_compatibility_score = calculator.calculate_policy_compatibility_score( + policy_match_score, implementation_stage_score, funding_support_score + ) + + # 计算政策乘数B13 + policy_multiplier = calculator.calculate_policy_multiplier_b13(policy_compatibility_score) + + print(f"政策匹配度: {policy_match_score:.2f}") + print(f"实施阶段评分: {implementation_stage_score:.2f}") + print(f"资金支持度: {funding_support_score:.2f}") + print(f"政策契合度评分P: {policy_compatibility_score:.2f}") + print(f"政策乘数B13: {policy_multiplier:.4f}") diff --git a/app/utils/calculation_engine/economic_value_b1/sub_formulas/traffic_factor_b12.py b/app/utils/calculation_engine/economic_value_b1/sub_formulas/traffic_factor_b12.py new file mode 100644 index 0000000..6e785ed --- /dev/null +++ b/app/utils/calculation_engine/economic_value_b1/sub_formulas/traffic_factor_b12.py @@ -0,0 +1,305 @@ +import math +from typing import Dict, Tuple + + + +class TrafficFactorB12Calculator: + """流量因子B12计算器""" + + def __init__(self): + """初始化计算器""" + pass + + def calculate_traffic_factor_b12(self, + search_index_s1: float, + industry_average_s2: float, + social_media_spread_s3: float) -> float: + """ + 计算流量因子B12 + + 流量因子B12 = ln(近30天搜索指数S1/行业均值S2) × 0.3 + 社交媒体传播度S3 × 0.7 + + Args: + search_index_s1: 近30天搜索指数S1 (API获取) + industry_average_s2: 行业均值S2 (系统配置) + social_media_spread_s3: 社交媒体传播度S3 (API获取) + + Returns: + float: 流量因子B12 + """ + # 避免除零和对数计算错误 + if industry_average_s2 <= 0: + raise ValueError("行业均值S2必须大于0") + + if search_index_s1 <= 0: + # 如果搜索指数为0或负数，使用最小值避免对数计算错误 + search_index_s1 = 1.0 + + # ，不进行任何拆分 + traffic_factor = (math.log(search_index_s1 / industry_average_s2) * 0.3 + + social_media_spread_s3 * 0.7) + + return traffic_factor + + def calculate_search_index_s1(self, + baidu_index: float, + wechat_index: float, + weibo_index: float) -> float: + """ + 计算近30天搜索指数S1 + + 近30天搜索指数S1 = 百度搜索指数 × 0.4 + 微信搜索指数 × 0.3 + 微博搜索指数 × 0.3 + + Args: + baidu_index: 百度搜索指数 (API获取) + wechat_index: 微信搜索指数 (API获取) + weibo_index: 微博搜索指数 (API获取) + + Returns: + float: 近30天搜索指数S1 + """ + # + search_index = (baidu_index * 0.4 + + wechat_index * 0.3 + + weibo_index * 0.3) + + return search_index + + def calculate_social_media_spread_s3(self, + interaction_index: float, + coverage_index: float, + conversion_efficiency: float) -> float: + """ + 计算社交媒体传播度S3 + + 社交媒体传播度S3 = 互动量指数 × 0.4 + 覆盖人群指数 × 0.3 + 转化效率 × 0.3 + + Args: + interaction_index: 互动量指数 (API获取) + coverage_index: 覆盖人群指数 (API获取) + conversion_efficiency: 转化效率 (用户填写) + + Returns: + float: 社交媒体传播度S3 + """ + # + social_media_spread = (interaction_index * 0.4 + + coverage_index * 0.3 + + conversion_efficiency * 0.3) + + return social_media_spread + + def calculate_interaction_index(self, + likes: int, + comments: int, + shares: int) -> float: + """ + 计算互动量指数 + + 互动量指数 = (点赞 + 评论 + 转发) / 1000 + + Args: + likes: 点赞数 (API获取) + comments: 评论数 (API获取) + shares: 转发数 (API获取) + + Returns: + float: 互动量指数 + """ + # + interaction_index = (likes + comments + shares) / 1000.0 + + return interaction_index + + def calculate_coverage_index(self, followers: int) -> float: + """ + 计算覆盖人群指数 + + 覆盖人群指数 = 粉丝数 / 10000 + + Args: + followers: 粉丝数 (API获取) + + Returns: + float: 覆盖人群指数 + """ + # + coverage_index = followers / 10000.0 + + return coverage_index + + def calculate_conversion_efficiency(self, + click_count: int, + view_count: int) -> float: + """ + 计算转化效率 + + ： + 转化效率 = 商品链接点击量 / 内容浏览量 + + Args: + click_count: 商品链接点击量 (用户填写) + view_count: 内容浏览量 (用户填写) + + Returns: + float: 转化效率 + """ + if view_count == 0: + return 0.0 + + # + conversion_efficiency = click_count / view_count + + return conversion_efficiency + + +class PlatformDataProcessor: + """平台数据处理类""" + + @staticmethod + def parse_platform_accounts(platform_data: str) -> Dict[str, str]: + """ + 解析平台账号数据 + + 输入格式：B站：12345678\n抖音：22334455 + + Args: + platform_data: 平台账号数据字符串 (用户填写) + + Returns: + Dict[str, str]: 平台账号字典 + """ + accounts = {} + lines = platform_data.strip().split('\n') + + for line in lines: + if '：' in line or ':' in line: + separator = '：' if '：' in line else ':' + parts = line.split(separator, 1) + if len(parts) == 2: + platform = parts[0].strip() + account = parts[1].strip() + accounts[platform] = account + + return accounts + + @staticmethod + def calculate_multi_platform_interaction(platform_data: Dict[str, Dict]) -> Tuple[float, float]: + """ + 计算多平台互动数据 + + Args: + platform_data: 平台数据字典，格式为 {平台名: {likes: int, comments: int, shares: int, followers: int}} (API获取) + + Returns: + Tuple[float, float]: (互动量指数, 覆盖人群指数) + """ + total_interactions = 0 + total_followers = 0 + + for platform, data in platform_data.items(): + # 计算互动量 + interactions = data.get('likes', 0) + data.get('comments', 0) + data.get('shares', 0) + total_interactions += interactions + + # 计算粉丝数 + followers = data.get('followers', 0) + total_followers += followers + + # 计算指数 + calculator = TrafficFactorB12Calculator() + interaction_index = calculator.calculate_interaction_index( + total_interactions, 0, 0 # 已经包含了所有互动数据 + ) + coverage_index = calculator.calculate_coverage_index(total_followers) + + return interaction_index, coverage_index + + +# 热度评分相关函数 +def calculate_heat_score(daily_views: float, favorites: int) -> float: + """ + 计算热度分 + + 热度评分标准： + - 高热度：近7日日均浏览量 > 1000，或收藏数 > 100 → 1.0 + - 中热度：近7日日均浏览量 ∈ [100, 1000]，或收藏数 ∈ [20, 100] → 0.6 + - 低热度：近7日日均浏览量 < 100，且收藏数 < 20 → 0.2 + - 无数据：无任何浏览与互动数据 → 0.0 + + Args: + daily_views: 近7日日均浏览量 (API获取) + favorites: 收藏数 (API获取) + + Returns: + float: 热度分 + """ + if daily_views > 1000 or favorites > 100: + return 1.0 + elif (daily_views >= 100 and daily_views <= 1000) or (favorites >= 20 and favorites <= 100): + return 0.6 + elif daily_views < 100 and favorites < 20: + return 0.2 + else: + return 0.0 + + +# 示例使用 +if __name__ == "__main__": + # 创建计算器实例 + calculator = TrafficFactorB12Calculator() + processor = PlatformDataProcessor() + + # 示例数据 + # 搜索指数数据 (API获取) + baidu_index = 6000.0 + wechat_index = 4500.0 + weibo_index = 3000.0 + + # 行业均值 (系统配置) + industry_average = 5000.0 + + # 平台账号数据 (用户填写) + platform_accounts = "B站：12345678\n抖音：22334455" + accounts = processor.parse_platform_accounts(platform_accounts) + + # 平台互动数据 (API获取) + platform_data = { + "B站": { + "likes": 1000, + "comments": 200, + "shares": 50, + "followers": 50000 + }, + "抖音": { + "likes": 2000, + "comments": 300, + "shares": 100, + "followers": 30000 + } + } + + # 转化效率数据 (用户填写) + click_count = 20 + view_count = 200 + + # 计算各项指标 + search_index_s1 = calculator.calculate_search_index_s1(baidu_index, wechat_index, weibo_index) + interaction_index, coverage_index = processor.calculate_multi_platform_interaction(platform_data) + conversion_efficiency = calculator.calculate_conversion_efficiency(click_count, view_count) + social_media_spread_s3 = calculator.calculate_social_media_spread_s3( + interaction_index, coverage_index, conversion_efficiency + ) + + # 计算流量因子B12 + traffic_factor = calculator.calculate_traffic_factor_b12( + search_index_s1, industry_average, social_media_spread_s3 + ) + + print(f"近30天搜索指数S1: {search_index_s1:.2f}") + print(f"行业均值S2: {industry_average:.2f}") + print(f"互动量指数: {interaction_index:.4f}") + print(f"覆盖人群指数: {coverage_index:.4f}") + print(f"转化效率: {conversion_efficiency:.4f}") + print(f"社交媒体传播度S3: {social_media_spread_s3:.4f}") + print(f"流量因子B12: {traffic_factor:.4f}") \ No newline at end of file