# GPT-5技术分析工具
class GPT5Analyzer:
    def __init__(self):
        self.specifications = {
            "参数量": "1.2万亿",
            "训练数据": "10万亿token",
            "上下文长度": "128K tokens",
            "多模态支持": ["文本", "图像", "音频", "视频"],
            "推理成本": "比GPT-4降低70%",
            "新功能": ["实时学习", "长期记忆", "代码执行", "数学推理"]
        }
    
    def analyze_impact(self, industry):
        """分析对特定行业的影响"""
        impacts = {
            "教育": ["个性化教学", "智能辅导", "自动评分", "课程生成"],
            "医疗": ["诊断辅助", "病历分析", "药物研发", "患者咨询"],
            "金融": ["风险评估", "投资建议", "欺诈检测", "客服自动化"],
            "创作": ["内容生成", "剧本创作", "音乐作曲", "艺术设计"]
        }
        
        return impacts.get(industry, ["通用AI助手"])
    
    def calculate_productivity_gain(self, task_type):
        """计算生产力提升"""
        gains = {
            "写作": 3.5,  # 3.5倍提升
            "编程": 2.8,
            "数据分析": 4.2,
            "研究": 3.0,
            "设计": 2.5
        }
        
        return gains.get(task_type, 2.0)

# 使用示例
analyzer = GPT5Analyzer()
print("GPT-5技术规格:")
for key, value in analyzer.specifications.items():
    print(f"  {key}: {value}")

print("\n对教育行业的影响:")
for impact in analyzer.analyze_impact("教育"):
    print(f"  • {impact}")

print(f"\n编程生产力提升: {analyzer.calculate_productivity_gain('编程')}倍")

# Blackwell Ultra性能分析
class BlackwellUltraBenchmark:
    def __init__(self):
        self.specs = {
            "工艺制程": "4nm",
            "晶体管数量": "2080亿",
            "FP8性能": "20 PetaFLOPS",
            "HBM4容量": "192GB",
            "能效比": "比前代提升2.3倍",
            "光追AI加速": "支持实时光线追踪AI训练"
        }
        
        self.benchmarks = {
            "GPT-5训练": {"时间减少": "40%", "能耗降低": "35%"},
            "Stable Diffusion 3": {"生成速度": "2.5倍", "分辨率": "8K实时"},
            "自动驾驶训练": {"模拟效率": "3倍提升", "成本降低": "50%"},
            "药物发现": {"分子模拟": "100倍加速", "成功率": "提升20%"}
        }
    
    def estimate_cost_savings(self, workload, duration_months=12):
        """估算成本节省"""
        base_costs = {
            "大模型训练": 5000000,  # 500万美元/月
            "图像生成": 200000,     # 20万美元/月
            "科学计算": 1000000,    # 100万美元/月
            "游戏渲染": 500000      # 50万美元/月
        }
        
        savings_rate = {
            "大模型训练": 0.35,
            "图像生成": 0.40,
            "科学计算": 0.45,
            "游戏渲染": 0.30
        }
        
        base = base_costs.get(workload, 0)
        savings = base * savings_rate.get(workload, 0) * duration_months
        
        return {
            "月基础成本": f"${base:,}",
            "节省比例": f"{savings_rate.get(workload, 0)*100:.0f}%",
            "年节省金额": f"${savings:,.0f}",
            "投资回报期": f"{base*3/savings*12:.1f}个月" if savings > 0 else "N/A"
        }

# 使用示例
benchmark = BlackwellUltraBenchmark()
print("Blackwell Ultra技术规格:")
for key, value in benchmark.specs.items():
    print(f"  {key}: {value}")

print("\n大模型训练成本节省分析:")
savings = benchmark.estimate_cost_savings("大模型训练")
for key, value in savings.items():
    print(f"  {key}: {value}")

# 智算2030计划分析
class ChinaAI2030Plan:
    def __init__(self):
        self.investment_breakdown = {
            "基础设施建设": 4000,  # 亿元
            "技术研发": 2500,
            "人才培养": 1500,
            "企业扶持": 1000,
            "国际合作": 500,
            "标准制定": 500
        }
        
        self.regional_distribution = {
            "京津冀": {"智算中心": 2, "投资": 1500, "重点领域": ["自动驾驶", "智慧城市"]},
            "长三角": {"智算中心": 3, "投资": 2000, "重点领域": ["智能制造", "金融科技"]},
            "粤港澳": {"智算中心": 2, "投资": 1800, "重点领域": ["医疗AI", "跨境电商"]},
            "成渝地区": {"智算中心": 1, "投资": 800, "重点领域": ["智慧农业", "文旅AI"]},
            "其他地区": {"智算中心": 2, "投资": 900, "重点领域": ["能源AI", "教育科技"]}
        }
    
    def calculate_economic_impact(self):
        """计算经济效益"""
        # 乘数效应：1元AI投资带动3元GDP增长
        total_investment = sum(self.investment_breakdown.values())
        gdp_impact = total_investment * 3
        
        # 就业创造：每亿元投资创造100个高薪岗位
        jobs_created = total_investment * 100
        
        # 企业成长：孵化1000家独角兽，市值总和10万亿元
        unicorn_value = 100000  # 亿元
        
        return {
            "总投资": f"{total_investment}亿元",
            "GDP带动": f"{gdp_impact}亿元",
            "就业创造": f"{jobs_created:,}个",
            "独角兽市值": f"{unicorn_value}亿元",
            "投资回报率": "1:8 (投资:经济价值)"
        }
    
    def analyze_regional_advantages(self, region):
        """分析区域优势"""
        if region not in self.regional_distribution:
            return None
        
        data = self.regional_distribution[region]
        advantages = []
        
        if region == "长三角":
            advantages.append("制造业基础雄厚，产业链完整")
            advantages.append("金融中心，资金充裕")
            advantages.append("高校密集，人才储备丰富")
        elif region == "粤港澳":
            advantages.append("国际化程度高，连接全球")
            advantages.append("医疗资源丰富，数据充足")
            advantages.append("跨境电商发达，应用场景多")
        
        return {
            "区域": region,
            "智算中心": data["智算中心"],
            "投资额": f"{data['投资']}亿元",
            "重点领域": data["重点领域"],
            "区域优势": advantages
        }

# 使用示例
plan = ChinaAI2030Plan()
print("智算2030投资分布:")
for category, amount in plan.investment_breakdown.items():
    print(f"  {category}: {amount}亿元")

impact = plan.calculate_economic_impact()
print("\n经济效益预测:")
for key, value in impact.items():
    print(f"  {key}: {value}")

print("\n长三角区域分析:")
region_analysis = plan.analyze_regional_advantages("长三角")
for key, value in region_analysis.items():
    if isinstance(value, list):
        print(f"  {key}:")
        for item in value:
            print(f"    • {item}")
    else:
        print(f"  {key}: {value}")

# 2026年Q1 AI投资数据分析
class AIInvestmentAnalysis:
    def __init__(self):
        self.q1_2026_data = {
            "总投资额": 850,  # 十亿美元
            "同比增长": 0.35,  # 35%
            "交易数量": 1250,
            "平均估值": 1.2,  # 十亿美元
            
            "细分领域": {
                "基础模型": {"金额": 300, "占比": 0.35, "增长率": 0.50},
                "行业应用": {"金额": 250, "占比": 0.29, "增长率": 0.40},
                "AI芯片": {"金额": 150, "占比": 0.18, "增长率": 0.60},
                "工具平台": {"金额": 100, "占比": 0.12, "增长率": 0.30},
                "其他": {"金额": 50, "占比": 0.06, "增长率": 0.25}
            },
            
            "地区分布": {
                "北美": {"金额": 400, "占比": 0.47},
                "亚洲": {"金额": 300, "占比": 0.35},
                "欧洲": {"金额": 100, "占比": 0.12},
                "其他": {"金额": 50, "占比": 0.06}
            },
            
            "投资轮次": {
                "种子轮": {"数量": 400, "平均金额": 5},  # 百万美元
                "A轮": {"数量": 300, "平均金额": 20},
                "B轮": {"数量": 200, "平均金额": 50},
                "C轮及以上": {"数量": 150, "平均金额": 100},
                "并购": {"数量": 200, "平均金额": 200}
            }
        }
    
    def generate_investment_report(self):
        """生成投资报告"""
        report = "2026年Q1 AI投资报告\n"
        report += "=" * 50 + "\n\n"
        
        total = self.q1_2026_data["总投资额"]
        growth = self.q1_2026_data["同比增长"] * 100
        
        report += f"总投资额: ${total}B (同比增长{growth:.1f}%)\n"
        report += f"交易数量: {self.q1_2026_data['交易数量']}笔\n"
        report += f"平均估值: ${self.q1_2026_data['平均估值']}B\n\n"
        
        report += "细分领域投资:\n"
        for sector, data in self.q1_2026_data["细分领域"].items():
            amount = data["金额"]
            share = data["占比"] * 100
            sector_growth = data["增长率"] * 100
            report += f"  {sector}: ${amount}B ({share:.1f}%), 增长{sector_growth:.1f}%\n"
        
        report += "\n地区分布:\n"
        for region, data in self.q1_2026_data["地区分布"].items():
            amount = data["金额"]
            share = data["占比"] * 100
            report += f"  {region}: ${amount}B ({share:.1f}%)\n"
        
        report += "\n投资轮次分析:\n"
        for stage, data in self.q1_2026_data["投资轮次"].items():
            count = data["数量"]
            avg_amount = data["平均金额"]
            report += f"  {stage}: {count}笔, 平均${avg_amount}M\n"
        
        # 趋势预测
        report += "\n📈 趋势预测:\n"
        report += "  1. 基础模型投资将继续主导 (40%+占比)\n"
        report += "  2. AI芯片投资增速最快 (60%+增长)\n"
        report += "  3. 亚洲市场占比将提升至40%\n"
        report += "  4. 并购活动将更加活跃\n"
        
        return report
    
    def identify_hot_sectors(self, threshold=0.40):
        """识别热门投资领域"""
        hot_sectors = []
        for sector, data in self.q1_2026_data["细分领域"].items():
            if data["增长率"] >= threshold:
                hot_sectors.append({
                    "领域": sector,
                    "增长率": f"{data['增长率']*100:.1f}%",
                    "投资额": f"${data['金额']}B",
                    "投资建议": self._get_investment_advice(sector)
                })
        
        return hot_sectors
    
    def _get_investment_advice(self, sector):
        """获取投资建议"""
        advice_map = {
            "基础模型": "长期持有，关注技术突破",
            "行业应用": "选择垂直领域龙头",
            "AI芯片": "硬件+软件生态布局",
            "工具平台": "关注开发者社区规模",
            "其他": "谨慎评估，分散风险"
        }
        return advice_map.get(sector, "需进一步分析")

# 使用示例
investment = AIInvestmentAnalysis()
print(investment.generate_investment_report())

print("🔥 热门投资领域:")
for sector in investment.identify_hot_sectors():
    print(f"\n{sector['领域']}:")
    print(f"  增长率: {sector['增长率']}")
    print(f"  投资额: {sector['投资额']}")
    print(f"  建议: {sector['投资建议']}")

# AI就业市场分析
class AIJobMarket:
    def __init__(self):
        self.job_data = {
            "总岗位数": 5000000,  # 500万
            "同比增长": 0.25,     # 25%
            
            "岗位类型": {
                "研发岗位": {"数量": 1500000, "增长": 0.30, "平均薪资": 35},  # 万美元
                "工程岗位": {"数量": 1200000, "增长": 0.25, "平均薪资": 25},
                "产品岗位": {"数量": 800000, "增长": 0.20, "平均薪资": 20},
                "数据岗位": {"数量": 700000, "增长": 0.35, "平均薪资": 18},
                "其他岗位": {"数量": 800000, "增长": 0.15, "平均薪资": 15}
            },
            
            "技能需求": {
                "Python": {"需求度": 0.95, "重要性": "核心"},
                "深度学习": {"需求度": 0.85, "重要性": "核心"},
                "云计算": {"需求度": 0.80, "重要性": "重要"},
                "大数据": {"需求度": 0.75, "重要性": "重要"},
                "产品思维": {"需求度": 0.70, "重要性": "加分"},
                "商业分析": {"需求度": 0.65, "重要性": "加分"}
            },
            
            "地区需求": {
                "硅谷": {"岗位数": 500000, "竞争指数": 0.9, "平均薪资": 40},
                "北京": {"岗位数": 300000, "竞争指数": 0.8, "平均薪资": 25},
                "班加罗尔": {"岗位数": 250000, "竞争指数": 0.7, "平均薪资": 15},
                "伦敦": {"岗位数": 200000, "竞争指数": 0.85, "平均薪资": 35},
                "其他地区": {"岗位数": 3750000, "竞争指数": 0.6, "平均薪资": 20}
            }
        }
    
    def generate_career_guide(self, experience_level="entry"):
        """生成职业发展指南"""
        guides = {
            "entry": {
                "目标岗位": ["AI工程师助理", "数据分析师", "机器学习实习生"],
                "                "必备技能": ["Python基础", "机器学习基础", "SQL", "Git"],
                "学习路径": "6个月在线课程 + 项目实践",
                "薪资范围": "$80K - $120K",
                "成长时间": "1-2年达到中级水平"
            },
            "mid": {
                "目标岗位": ["机器学习工程师", "数据科学家", "AI产品经理"],
                "必备技能": ["深度学习", "模型部署", "产品设计", "团队协作"],
                "学习路径": "专业认证 + 行业项目",
                "薪资范围": "$120K - $200K",
                "成长时间": "2-3年达到高级水平"
            },
            "senior": {
                "目标岗位": ["AI架构师", "技术总监", "首席科学家"],
                "必备技能": ["系统设计", "技术规划", "团队管理", "商业洞察"],
                "学习路径": "行业经验 + 领导力培养",
                "薪资范围": "$200K - $500K+",
                "成长时间": "5+年成为专家"
            }
        }
        
        guide = guides.get(experience_level, guides["entry"])
        
        report = f"AI职业发展指南 ({experience_level}级)\n"
        report += "=" * 50 + "\n\n"
        
        report += "🎯 目标岗位:\n"
        for job in guide["目标岗位"]:
            report += f"  • {job}\n"
        
        report += f"\n📚 必备技能:\n"
        for skill in guide["必备技能"]:
            report += f"  • {skill}\n"
        
        report += f"\n🛣️ 学习路径: {guide['学习路径']}\n"
        report += f"💰 薪资范围: {guide['薪资范围']}\n"
        report += f"⏱️ 成长时间: {guide['成长时间']}\n"
        
        # 添加市场数据
        total_jobs = self.job_data["总岗位数"]
        growth = self.job_data["同比增长"] * 100
        
        report += f"\n📊 市场数据:\n"
        report += f"  总岗位数: {total_jobs:,}\n"
        report += f"  同比增长: {growth:.1f}%\n"
        
        return report
    
    def analyze_skill_gap(self):
        """分析技能缺口"""
        skill_gaps = []
        
        for skill, data in self.job_data["技能需求"].items():
            demand = data["需求度"]
            importance = data["重要性"]
            
            # 假设当前人才供应为需求度的70%
            supply = demand * 0.7
            gap = demand - supply
            
            if gap > 0.2:  # 缺口大于20%
                skill_gaps.append({
                    "技能": skill,
                    "需求度": f"{demand*100:.0f}%",
                    "重要性": importance,
                    "缺口": f"{gap*100:.0f}%",
                    "紧急程度": "高" if gap > 0.3 else "中"
                })
        
        # 按缺口大小排序
        skill_gaps.sort(key=lambda x: float(x["缺口"][:-1]), reverse=True)
        
        return skill_gaps

# 使用示例
job_market = AIJobMarket()
print(job_market.generate_career_guide("mid"))

print("\n🔍 技能缺口分析:")
gaps = job_market.analyze_skill_gap()
for gap in gaps[:5]:  # 显示前5个最大缺口
    print(f"\n{gap['技能']}:")
    print(f"  需求度: {gap['需求度']}")
    print(f"  重要性: {gap['重要性']}")
    print(f"  缺口: {gap['缺口']}")
    print(f"  紧急程度: {gap['紧急程度']}")

# 科技巨头AI战略分析
class TechGiantsAIStrategy:
    def __init__(self):
        self.strategies = {
            "微软": {
                "投资重点": ["OpenAI合作", "Azure AI云", "Copilot生态", "企业AI解决方案"],
                "2026目标": "AI收入$500亿",
                "竞争优势": "企业客户基础，云+AI整合",
                "风险": "过度依赖OpenAI，竞争加剧"
            },
            "谷歌": {
                "投资重点": ["Gemini模型", "TPU芯片", "搜索AI化", "Workspace集成"],
                "2026目标": "AI搜索占比50%",
                "竞争优势": "数据规模，搜索垄断",
                "风险": "创新速度，监管压力"
            },
            "Meta": {
                "投资重点": ["Llama开源", "元宇宙AI", "广告优化", "社交AI助手"],
                "2026目标": "AI推荐提升30%",
                "竞争优势": "社交数据，开源生态",
                "风险": "隐私争议，元宇宙进展"
            },
            "亚马逊": {
                "投资重点": ["AWS Bedrock", "Alexa升级", "物流优化", "零售AI"],
                "2026目标": "AWS AI服务增长40%",
                "竞争优势": "云基础设施，电商数据",
                "风险": "消费者AI落后，利润率压力"
            },
            "苹果": {
                "投资重点": ["设备端AI", "Siri重构", "健康AI", "隐私保护AI"],
                "2026目标": "每台设备AI芯片",
                "竞争优势": "硬件生态，用户忠诚度",
                "风险": "云AI落后，封闭生态"
            }
        }
    
    def compare_strategies(self):
        """比较各公司战略"""
        comparison = []
        
        for company, strategy in self.strategies.items():
            score = self._calculate_strategy_score(strategy)
            
            comparison.append({
                "公司": company,
                "战略得分": score,
                "投资重点": ", ".join(strategy["投资重点"][:2]),
                "竞争优势": strategy["竞争优势"],
                "风险等级": self._assess_risk(strategy["风险"])
            })
        
        # 按得分排序
        comparison.sort(key=lambda x: x["战略得分"], reverse=True)
        
        return comparison
    
    def _calculate_strategy_score(self, strategy):
        """计算战略得分"""
        score = 0
        
        # 投资重点数量
        score += len(strategy["投资重点"]) * 5
        
        # 目标雄心程度
        if "收入" in strategy["2026目标"]:
            score += 30
        elif "增长" in strategy["2026目标"]:
            score += 25
        elif "占比" in strategy["2026目标"]:
            score += 20
        
        # 竞争优势强度
        advantages = strategy["竞争优势"]
        if "生态" in advantages or "垄断" in advantages:
            score += 25
        elif "数据" in advantages:
            score += 20
        else:
            score += 15
        
        return score
    
    def _assess_risk(self, risk_text):
        """评估风险等级"""
        risk_keywords = {
            "高": ["过度依赖", "垄断", "争议", "落后", "压力"],
            "中": ["竞争", "监管", "进展", "利润率"],
            "低": ["一般", "常规", "可控"]
        }
        
        risk_level = "低"
        for level, keywords in risk_keywords.items():
            for keyword in keywords:
                if keyword in risk_text:
                    risk_level = level
                    break
            if risk_level != "低":
                break
        
        return risk_level
    
    def predict_winner(self, timeframe="2026"):
        """预测胜出者"""
        comparison = self.compare_strategies()
        
        if timeframe == "2026":
            # 短期看执行力和现有优势
            weights = {"微软": 1.2, "谷歌": 1.1, "亚马逊": 1.0, "Meta": 0.9, "苹果": 0.8}
        else:  # 长期
            # 长期看创新和生态建设
            weights = {"谷歌": 1.2, "微软": 1.1, "苹果": 1.0, "Meta": 0.9, "亚马逊": 0.8}
        
        weighted_scores = []
        for item in comparison:
            company = item["公司"]
            base_score = item["战略得分"]
            weighted_score = base_score * weights.get(company, 1.0)
            
            weighted_scores.append({
                "公司": company,
                "原始得分": base_score,
                "加权得分": weighted_score,
                "排名变化": "待计算"
            })
        
        # 按加权得分排序
        weighted_scores.sort(key=lambda x: x["加权得分"], reverse=True)
        
        # 计算排名变化
        original_ranking = {item["公司"]: i for i, item in enumerate(comparison)}
        for i, item in enumerate(weighted_scores):
            original_rank = original_ranking[item["公司"]] + 1
            current_rank = i + 1
            change = original_rank - current_rank
            
            if change > 0:
                rank_change = f"上升{change}位"
            elif change < 0:
                rank_change = f"下降{-change}位"
            else:
                rank_change = "不变"
            
            item["排名变化"] = rank_change
        
        return weighted_scores

# 使用示例
tech_analysis = TechGiantsAIStrategy()
print("🏆 科技巨头AI战略比较:")
comparison = tech_analysis.compare_strategies()
for i, item in enumerate(comparison, 1):
    print(f"\n{i}. {item['公司']} (得分: {item['战略得分']})")
    print(f"   投资重点: {item['投资重点']}")
    print(f"   竞争优势: {item['竞争优势']}")
    print(f"   风险等级: {item['风险等级']}")

print("\n🔮 2026年预测排名:")
predictions = tech_analysis.predict_winner("2026")
for i, pred in enumerate(predictions[:3], 1):
    print(f"{i}. {pred['公司']}: 得分{pred['加权得分']:.1f} ({pred['排名变化']})")

# 初创公司投资分析工具
class StartupInvestmentAnalyzer:
    def __init__(self):
        self.recent_deals = [
            {
                "公司": "NeuroSynth",
                "轮次": "C轮",
                "金额": 2.5,  # 亿美元
                "估值": 15.0,
                "领域": "脑机接口AI",
                "投资方": ["a16z", "红杉", "Temasek"],
                "技术亮点": "非侵入式脑信号解码，准确率85%"
            },
            {
                "公司": "QuantumAI",
                "轮次": "B轮",
                "金额": 1.8,
                "估值": 8.0,
                "领域": "量子机器学习",
                "投资方": ["Google Ventures", "Bessemer"],
                "技术亮点": "量子算法加速传统ML 100倍"
            },
            {
                "公司": "EcoMind",
                "轮次": "A轮",
                "金额": 1.2,
                "估值": 5.0,
                "领域": "气候AI解决方案",
                "投资方": ["Breakthrough", "Climate Pledge"],
                "技术亮点": "碳足迹追踪、可再生能源优化"
            }
        ]
    
    def analyze_deal_metrics(self):
        """分析交易指标"""
        analysis = []
        
        for deal in self.recent_deals:
            # 计算估值倍数
            amount = deal["金额"]
            valuation = deal["估值"]
            
            # 假设收入为估值的1/10
            estimated_revenue = valuation / 10
            
            # PS比率 (市销率)
            ps_ratio = valuation / estimated_revenue if estimated_revenue > 0 else 0
            
            # 投资回报潜力 (假设退出时5倍回报)
            exit_potential = valuation * 5
            roi_multiple = exit_potential / amount if amount > 0 else 0
            
            analysis.append({
                "公司": deal["公司"],
                "轮次": deal["轮次"],
                "投资额": f"${amount:.1f}亿",
                "估值": f"${valuation:.1f}亿",
                "PS比率": f"{ps_ratio:.1f}x",
                "ROI潜力": f"{roi_multiple:.1f}x",
                "投资吸引力": self._assess_attractiveness(deal["领域"], ps_ratio)
            })
        
        return analysis
    
    def _assess_attractiveness(self, sector, ps_ratio):
        """评估投资吸引力"""
        sector_premiums = {
            "脑机接口AI": 1.5,
            "量子机器学习": 2.0,
            "气候AI解决方案": 1.2,
            "通用AI": 1.0
        }
        
        premium = sector_premiums.get(sector, 1.0)
        adjusted_ps = ps_ratio / premium
        
        if adjusted_ps < 10:
            return "高吸引力"
        elif adjusted_ps < 20:
            return "中等吸引力"
        else:
            return "低吸引力"
    
    def identify_trends(self):
        """识别投资趋势"""
        trends = {
            "热门领域": [],
            "投资规模": {"总额": 0, "平均": 0, "最大": 0},
            "投资方偏好": {},
            "估值水平": {"平均": 0, "中位数": 0}
        }
        
        # 分析领域分布
        sectors = {}
        total_amount = 0
        valuations = []
        
        for deal in self.recent_deals:
            sector = deal["领域"]
            amount = deal["金额"]
            valuation = deal["估值"]
            
            sectors[sector] = sectors.get(sector, 0) + amount
            total_amount += amount
            valuations.append(valuation)
            
            # 记录投资方
            for investor in deal["投资方"]:
                trends["投资方偏好"][investor] = trends["投资方偏好"].get(investor, 0) + 1
        
        # 找出热门领域
        sorted_sectors = sorted(sectors.items(), key=lambda x: -x[1])
        trends["热门领域"] = [sector for sector, _ in sorted_sectors[:3]]
        
        # 计算统计指标
        trends["投资规模"]["总额"] = total_amount
        trends["投资规模"]["平均"] = total_amount / len(self.recent_deals)
        trends["投资规模"]["最大"] = max(deal["金额"] for deal in self.recent_deals)
        
        trends["估值水平"]["平均"] = sum(valuations) / len(valuations)
        sorted_vals = sorted(valuations)
        mid = len(sorted_vals) // 2
        trends["估值水平"]["中位数"] = sorted_vals[mid] if len(sorted_vals) % 2 == 1 else (sorted_vals[mid-1] + sorted_vals[mid]) / 2
        
        return trends

# 使用示例
startup_analyzer = StartupInvestmentAnalyzer()
print("💰 近期重大融资分析:")
deals = startup_analyzer.analyze_deal_metrics()
for deal in deals:
    print(f"\n{deal['公司']} ({deal['轮次']}):")
    print(f"  投资额: {deal['投资额']}")
    print(f"  估值: {deal['估值']}")
    print(f"  PS比率: {deal['PS比率']}")
    print(f"  ROI潜力: {deal['ROI潜力']}")
    print(f"  投资吸引力: {deal['投资吸引力']}")

print("\n📈 投资趋势分析:")
trends = startup_analyzer.identify_trends()
print(f"热门领域: {', '.join(trends['热门领域'])}")
print(f"总投资额: ${trends['投资规模']['总额']:.1f}亿")
print(f"平均估值: ${trends['估值水平']['平均']:.1f}亿")
print(f"活跃投资方: {', '.join(list(trends['投资方偏好'].keys())[:3])}")

# AI监管政策跟踪
class AIRegulationTracker:
    def __init__(self):
        self.policies = {
            "欧盟": {
                "AI法案状态": "已实施",
                "关键条款": ["高风险AI禁止", "透明度要求", "数据治理", "处罚机制"],
                "影响范围": "所有在欧运营的AI公司",
                "合规成本": "预计增加15-25%",
                "生效时间": "2026年1月"
            },
            "美国": {
                "AI法案状态": "立法中",
                "关键条款": ["安全标准", "算法审计", "反垄断", "国家AI战略"],
                "影响范围": "大型科技公司优先",
                "合规成本": "预计增加10-20%",
                "预计生效": "2026年底"
            },
            "中国": {
                "AI法案状态": "已实施",
                "关键条款": ["数据安全法", "算法推荐管理", "生成式AI备案", "科技伦理"],
                "影响范围": "境内所有AI服务",
                "合规成本": "预计增加20-30%",
                "生效时间": "2025年7月"
            },
            "英国": {
                "AI法案状态": "咨询阶段",
                "关键条款": ["创新友好", "风险分级", "行业自律", "国际协调"],
                "影响范围": "基于风险的方法",
                "合规成本": "预计增加5-15%",
                "预计生效": "2027年"
            }
        }
    
    def compare_regulatory_approaches(self):
        """比较监管方式"""
        approaches = []
        
        for region, policy in self.policies.items():
            strictness = self._calculate_strictness(policy)
            innovation_friendliness = self._assess_innovation_friendliness(policy)
            
            approaches.append({
                "地区": region,
                "监管严格度": strictness,
                "创新友好度": innovation_friendliness,
                "合规复杂度": policy["合规成本"],
                "实施状态": policy["AI法案状态"],
                "建议策略": self._generate_strategy_recommendation(region, strictness)
            })
        
        return approaches
    
    def _calculate_strictness(self, policy):
        """计算监管严格度"""
        strictness_score = 0
        
        # 状态权重
        status_weights = {"已实施": 1.0, "立法中": 0.7, "咨询阶段": 0.4}
        strictness_score += status_weights.get(policy["AI法案状态"], 0.5) * 30
        
        # 条款数量
        strictness_score += len(policy["关键条款"]) * 10
        
        # 合规成本
        cost_range = policy["合规成本"].replace("预计增加", "").replace("%", "")
        try:
            cost = float(cost_range.split("-")[0])
            strictness_score += cost * 2
        except:
            strictness_score += 20
        
        # 影响范围
        if "所有" in policy["影响范围"]:
            strictness_score += 20
        elif "大型" in policy["影响范围"]:
            strictness_score += 15
        else:
            strictness_score += 10
        
        # 转换为0-100分
        return min(100, strictness_score)
    
    def _assess_innovation_friendliness(self, policy):
        """评估创新友好度"""
        friendly_keywords = ["创新友好", "行业自律", "风险分级", "协调"]
        restrictive_keywords = ["禁止", "处罚", "备案", "审计"]
        
        friendliness = 50  # 基准分
        
        # 分析关键条款
        for clause in policy["关键条款"]:
            for keyword in friendly_keywords:
                if keyword in clause:
                    friendliness += 10
            for keyword in restrictive_keywords:
                if keyword in clause:
                    friendliness -= 10
        
        # 状态影响
        if policy["AI法案状态"] == "咨询阶段":
            friendliness += 15
        elif policy["AI法案状态"] == "立法中":
            friendliness += 5
        
        return max(0, min(100, friendliness))
    
    def _generate_strategy_recommendation(self, region, strictness):
        """生成策略建议"""
        if strictness > 70:
            return "优先合规，考虑本地化团队"
        elif strictness > 40:
            return "监控政策变化，准备合规方案"
        else:
            return "保持关注，灵活调整"
    
    def generate_compliance_checklist(self, company_size="medium"):
        """生成合规检查清单"""
        checklists = {
            "small": [
                "数据隐私政策更新",
                "算法透明度说明",
                "用户同意机制",
                "基础安全措施"
            ],
            "medium": [
                "风险评估报告",
                "算法影响评估",
                "数据治理框架",
                "合规团队设立",
                "第三方审计准备"
            ],
            "large": [
                "全面合规体系",
                "伦理委员会成立",
                "全球政策跟踪",
                "应急预案制定",
                "定期合规报告",
                "政府关系维护"
            ]
        }
        
        checklist = checklists.get(company_size, checklists["medium"])
        
        report = f"AI合规检查清单 ({company_size}规模企业)\n"
        report += "=" * 50 + "\n\n"
        
        report += "📋 必做事项:\n"
        for i, item in enumerate(checklist, 1):
            report += f"{i}. {item}\n"
        
        report += f"\n⏰ 时间建议:\n"
        if company_size == "small":
            report += "  准备时间: 1-3个月\n"
            report += "  年度维护: 20-50小时\n"
            report += "  预算建议: $10K - $50K\n"
        elif company_size == "medium":
            report += "  准备时间: 3-6个月\n"
            report += "  年度维护: 100-200小时\n"
            report += "  预算建议: $50K - $200K\n"
        else:
            report += "  准备时间: 6-12个月\n"
            report += "  年度维护: 500+小时\n"
            report += "  预算建议: $200K - $1M+\n"
        
        report += "\n🌍 地区特别要求:\n"
        for region, policy in self.policies.items():
            if policy["AI法案状态"] == "已实施":
                report += f"  • {region}: {policy['关键条款'][0]}\n"
        
        return report

# 使用示例
regulation = AIRegulationTracker()
print("🌐 全球AI监管比较:")
approaches = regulation.compare_regulatory_approaches()
for approach in approaches:
    print(f"\n{approach['地区']}:")
    print(f"  监管严格度: {approach['监管严格度']:.0f}/100")
    print(f"  创新友好度: {approach['创新友好度']:.0f}/100")
    print(f"  合规复杂度: {approach['合规复杂度']}")
    print(f"  建议策略: {approach['建议策略']}")

print("\n" + regulation.generate_compliance_checklist("medium"))

# AI行业预测模型
class AIPredictions2026:
    def __init__(self):
        self.predictions = {
            "技术突破": [
                "多模态模型统一架构出现",
                "AI芯片能效比再提升50%",
                "边缘AI设备普及率超30%",
                "AI生成视频达到电影级质量"
            ],
            "商业应用": [
                "AI医生辅助诊断覆盖50%医院",
                "自动驾驶L4级别商业化运营",
                "AI设计工具取代30%初级设计师",
                "智能客服解决80%客户问题"
            ],
            "投资趋势": [
                "AI基础设施投资增长40%",
                "垂直领域AI应用融资活跃",
                "并购整合加速，出现超级平台",
                "政府AI采购规模翻倍"
            ],
            "就业影响": [
                "AI相关岗位新增200万个",
                "50%工作岗位需要AI技能",
                "AI培训市场规模达$100B",
                "远程AI协作成为常态"
            ],
            "风险挑战": [
                "AI安全漏洞事件增加",
                "监管不确定性影响创新",
                "技术垄断加剧",
                "就业结构性调整压力"
            ]
        }
    
    def generate_forecast_report(self, confidence_level=0.8):
        """生成预测报告"""
        report = "2026年下半年AI行业预测报告\n"
        report += "=" * 60 + "\n\n"
        
        report += f"置信度: {confidence_level*100:.0f}%\n"
        report += "生成时间: 2026年4月12日\n\n"
        
        for category, items in self.predictions.items():
            report += f"📊 {category}:\n"
            for i, item in enumerate(items, 1):
                probability = self._calculate_probability(item, confidence_level)
                report += f"  {i}. {item} (概率: {probability}%)\n"
            report += "\n"
        
        # 关键洞察
        report += "🎯 关键洞察:\n"
        report += "  1. 技术突破将推动应用爆发\n"
        report += "  2. 投资重点从基础模型转向应用\n"
        report += "  3. 就业市场结构性变化加速\n"
        report += "  4. 监管与创新需要平衡\n"
        
        # 行动建议
        report += "\n💡 行动建议:\n"
        report += "  企业: 加快AI转型，投资人才培养\n"
        report += "  投资者: 关注垂直应用，分散风险\n"
        report += "  个人: 学习AI技能，适应变化\n"
        report += "  政府: 完善政策，支持创新\n"
        
        return report
    
    def _calculate_probability(self, prediction, base_confidence):
        """计算预测概率"""
        # 基于关键词调整概率
        probability = base_confidence * 100
        
        # 积极关键词
        positive_keywords = ["增长", "提升", "普及", "覆盖", "新增", "成为"]
        for keyword in positive_keywords:
            if keyword in prediction:
                probability += 5
        
        # 保守关键词
        conservative_keywords = ["可能", "预计", "有望", "逐步"]
        for keyword in conservative_keywords:
            if keyword in prediction:
                probability -= 10
        
        # 具体数字增加可信度
        import re
        numbers = re.findall(r'\d+%', prediction)
        if numbers:
            probability += len(numbers) * 3
        
        return f"{min(95, max(20, probability)):.0f}"
    
    def identify_opportunities(self, sector):
        """识别行业机会"""
        opportunity_map = {
            "医疗": [
                "AI辅助诊断系统",
                "个性化治疗方案",
                "药物研发加速",
                "医疗机器人"
            ],
            "教育": [
                "个性化学习平台",
                "智能教学助手",
                "自动评估系统",
                "虚拟实验室"
            ],
            "金融": [
                "智能投顾",
                "风险管理系统",
                "反欺诈检测",
                "自动化客服"
            ],
            "制造": [
                "智能质检",
                "预测性维护",
                "供应链优化",
                "柔性生产"
            ],
            "零售": [
                "个性化推荐",
                "智能库存管理",
                "无人商店",
                "客服机器人"
            ]
        }
        
        opportunities = opportunity_map.get(sector, ["数字化转型", "流程自动化"])
        
        report = f"{sector}行业AI机会分析\n"
        report += "=" * 40 + "\n\n"
        
        report += "🎯 重点机会领域:\n"
        for i, opportunity in enumerate(opportunities, 1):
            market_size = self._estimate_market_size(opportunity)
            growth_rate = self._estimate_growth_rate(opportunity)
            report += f"{i}. {opportunity}\n"
            report += f"   市场规模: {market_size}\n"
            report += f"   增长率: {growth_rate}\n"
        
        report += f"\n⏰ 时机建议:\n"
        if sector in ["医疗", "金融"]:
            report += "  立即行动，监管要求高\n"
        elif sector in ["教育", "零售"]:
            report += "  1年内布局，市场正在形成\n"
        else:
            report += "  2-3年规划，技术逐步成熟\n"
        
        return report
    
    def _estimate_market_size(self, opportunity):
        """估算市场规模"""
        sizes = {
            "AI辅助诊断系统": "$50B - $100B",
            "个性化学习平台": "$30B - $60B",
            "智能投顾": "$80B - $150B",
            "智能质检": "$20B - $40B",
            "个性化推荐": "$40B - $80B"
        }
        
        return sizes.get(opportunity, "$10B - $30B")
    
    def _estimate_growth_rate(self, opportunity):
        """估算增长率"""
        rates = {
            "AI辅助诊断系统": "25-35%",
            "个性化学习平台": "30-40%",
            "智能投顾": "20-30%",
            "智能质检": "35-45%",
            "个性化推荐": "25-35%"
        }
        
        return rates.get(opportunity, "20-30%")

# 使用示例
predictor = AIPredictions2026()
print(predictor.generate_forecast_report(0.85))

print("\n🏥 医疗行业机会分析:")
print(predictor.identify_opportunities("医疗"))

# 短期投资策略
class ShortTermInvestmentStrategy:
    def __init__(self):
        self.recommendations = {
            "买入": [
                {"标的": "AI芯片公司", "理由": "算力需求爆发，估值合理", "目标涨幅": "30-50%"},
                {"标的": "垂直行业AI应用", "理由": "商业化加速，增长确定", "目标涨幅": "20-40%"},
                {"标的": "AI基础设施", "理由": "政策支持，长期价值", "目标涨幅": "25-45%"}
            ],
            "持有": [
                {"标的": "大型科技股", "理由": "基本面稳健，等待催化", "目标涨幅": "10-20%"},
                {"标的": "AI ETF", "理由": "分散风险，行业增长", "目标涨幅": "15-25%"}
            ],
            "观望": [
                {"标的": "早期AI初创", "理由": "估值过高，风险较大", "建议": "等待调整"},
                {"标的": "概念炒作股", "理由": "缺乏实质业务", "建议": "避免参与"}
            ]
        }
    
    def generate_portfolio_allocation(self, risk_profile="moderate"):
        """生成投资组合配置"""
        allocations = {
            "保守": {"AI芯片": 0.20, "垂直应用": 0.15, "基础设施": 0.10, "科技股": 0.30, "现金": 0.25},
            "稳健": {"AI芯片": 0.25, "垂直应用": 0.20, "基础设施": 0.15, "科技股": 0.25, "现金": 0.15},
            "积极": {"AI芯片": 0.30, "垂直应用": 0.25, "基础设施": 0.20, "科技股": 0.20, "现金": 0.05}
        }
        
        allocation = allocations.get(risk_profile, allocations["稳健"])
        
        report = f"AI投资组合配置 ({risk_profile}风险偏好)\n"
        report += "=" * 50 + "\n\n"
        
        total = 0
        for category, weight in allocation.items():
            percentage = weight * 100
            total += percentage
            report += f"{category}: {percentage:.1f}%\n"
        
        report += f"\n总计: {total:.1f}%\n"
        
        # 预期回报
        expected_returns = {
            "保守": "8-12%",
            "稳健": "12-18%", 
            "积极": "18-25%"
        }
        
        report += f"预期年化回报: {expected_returns.get(risk_profile, '10-15%')}\n"
        report += f"最大回撤估计: {self._estimate_max_drawdown(risk_profile)}\n"
        
        return report
    
    def _estimate_max_drawdown(self, risk_profile):
        """估计最大回撤"""
        drawdowns = {
            "保守": "15-20%",
            "稳健": "20-30%",
            "积极": "30-40%"
        }
        return drawdowns.get(risk_profile, "20-25%")

# 使用示例
strategy = ShortTermInvestmentStrategy()
print("💰 短期投资建议:")
for action, items in strategy.recommendations.items():
    print(f"\n{action}:")
    for item in items:
        print(f"  • {item['标的']}: {item['理由']}")

print("\n" + strategy.generate_portfolio_allocation("稳健"))

# AI行业学习路径
class AILearningPath:
    def __init__(self):
        self.resources = {
            "入门": {
                "课程": ["AI For Everyone (Coursera)", "Fast.ai Practical Deep Learning"],
                "书籍": ["Artificial Intelligence: A Modern Approach", "Hands-On Machine Learning"],
                "工具": ["Google Colab", "Kaggle Notebooks"],
                "时间": "3-6个月"
            },
            "进阶": {
                "课程": ["Deep Learning Specialization", "Stanford CS231n"],
                "书籍": ["Deep Learning", "Pattern Recognition and Machine Learning"],
                "工具": ["PyTorch", "TensorFlow", "Hugging Face"],
                "时间": "6-12个月"
            },
            "专业": {
                "课程": ["PhD-level AI courses", "Industry certifications"],
                "书籍": ["Research papers", "Technical reports"],
                "工具": ["Custom frameworks", "Production deployment"],
                "时间": "1-2年"
            }
        }
    
    def generate_learning_plan(self, current_level, target_level, available_hours=10):
        """生成学习计划"""
        plan = f"AI学习计划: {current_level} → {target_level}\n"
        plan += "=" * 50 + "\n\n"
        
        # 估计总时间
        level_times = {"入门": 3, "进阶": 6, "专业": 12}  # 月
        total_months = level_times.get(target_level, 6) - level_times.get(current_level, 0)
        
        plan += f"📅 预计完成时间: {total_months}个月\n"
        plan += f"⏰ 每周学习时间: {available_hours}小时\n"
        plan        plan += f"📚 总学习时长: {total_months * 4 * available_hours}小时\n\n"
        
        # 月度计划
        plan += "🗓️ 月度学习计划:\n"
        for month in range(1, total_months + 1):
            if month <= 3:
                focus = "基础理论与工具"
            elif month <= 6:
                focus = "深度学习与项目"
            else:
                focus = "专业领域与部署"
            
            plan += f"  第{month}月: {focus}\n"
        
        # 资源推荐
        target_resources = self.resources.get(target_level, self.resources["进阶"])
        plan += f"\n📖 推荐资源 ({target_level}级):\n"
        
        plan += "  课程:\n"
        for course in target_resources["课程"][:2]:
            plan += f"    • {course}\n"
        
        plan += "  书籍:\n"
        for book in target_resources["书籍"][:2]:
            plan += f"    • {book}\n"
        
        plan += "  工具:\n"
        for tool in target_resources["工具"][:2]:
            plan += f"    • {tool}\n"
        
        # 项目建议
        plan += "\n🎯 项目建议:\n"
        projects = {
            "入门": ["MNIST分类", "电影推荐系统", "垃圾邮件检测"],
            "进阶": ["图像分割", "文本生成", "时间序列预测"],
            "专业": ["多模态模型", "生产部署", "论文复现"]
        }
        
        for project in projects.get(target_level, ["实践项目"]):
            plan += f"  • {project}\n"
        
        return plan

# 使用示例
learning = AILearningPath()
print(learning.generate_learning_plan("入门", "进阶", 15))