IBM暴跌25%深度分析：AI资本开支如何"吞掉"传统软件饭碗，高盛5.8万亿美金AI基建时代的产业重构

"""
IBM营收结构分析与AI预算挤占效应模拟
"""

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from typing import Dict, List

class IBMBudgetAnalysis:
    """IBM营收分析与AI预算挤占模型"""
    
    def __init__(self):
        # IBM 2025-2026部门营收数据（十亿美元）
        self.revenue_data = {
            'Software': {
                '2025Q2': 7.1, '2025Q3': 7.0, '2025Q4': 7.5, '2026Q1': 7.2,
                '2026Q2_actual': 7.0, '2026Q2_expected': 7.6
            },
            'Consulting': {
                '2025Q2': 5.2, '2025Q3': 5.1, '2025Q4': 5.3, '2026Q1': 5.0,
                '2026Q2_actual': 4.9, '2026Q2_expected': 5.1
            },
            'Infrastructure': {
                '2025Q2': 3.8, '2025Q3': 3.7, '2025Q4': 4.0, '2026Q1': 3.6,
                '2026Q2_actual': 3.5, '2026Q2_expected': 3.7
            },
            'Financing': {
                '2025Q2': 0.2, '2025Q3': 0.2, '2025Q4': 0.2, '2026Q1': 0.2,
                '2026Q2_actual': 0.2, '2026Q2_expected': 0.2
            }
        }
        
        # 企业IT预算分配数据（来自Gartner/IDC预测）
        self.it_budget_allocation = {
            '2022': {'traditional_software': 0.45, 'cloud': 0.30, 'ai': 0.10, 'infra': 0.15},
            '2023': {'traditional_software': 0.40, 'cloud': 0.32, 'ai': 0.15, 'infra': 0.13},
            '2024': {'traditional_software': 0.35, 'cloud': 0.33, 'ai': 0.20, 'infra': 0.12},
            '2025': {'traditional_software': 0.28, 'cloud': 0.32, 'ai': 0.30, 'infra': 0.10},
            '2026E': {'traditional_software': 0.22, 'cloud': 0.30, 'ai': 0.40, 'infra': 0.08},
        }
    
    def analyze_revenue_trend(self) -> pd.DataFrame:
        """分析营收趋势"""
        df = pd.DataFrame(self.revenue_data)
        df.index = ['2025Q2', '2025Q3', '2025Q4', '2026Q1', '2026Q2_actual', '2026Q2_expected']
        
        print("=== IBM部门营收趋势（十亿美元） ===")
        print(df.to_string())
        
        # 计算同比增速
        yoy = (df.loc['2026Q2_actual'] - df.loc['2025Q2']) / df.loc['2025Q2'] * 100
        print(f"\n=== 同比增速(YoY) ===")
        for col in yoy.index:
            print(f"{col}: {yoy[col]:.1f}%")
        
        return df
    
    def simulate_budget_crowding_out(self) -> Dict:
        """模拟AI预算挤占效应"""
        print("\n=== 企业IT预算分配演变 ===")
        print(f"{'年份':<8} {'传统软件':<12} {'云服务':<10} {'AI':<10} {'基础设施':<12}")
        print("-" * 52)
        
        for year, alloc in self.it_budget_allocation.items():
            print(f"{year:<8} {alloc['traditional_software']:<12.0%} "
                  f"{alloc['cloud']:<10.0%} {alloc['ai']:<10.0%} "
                  f"{alloc['infra']:<12.0%}")
        
        # 计算传统软件被挤占比例
        base = self.it_budget_allocation['2022']['traditional_software']
        current = self.it_budget_allocation['2026E']['traditional_software']
        crowding_out = (base - current) / base * 100
        
        print(f"\n传统软件占比从2022年的{base:.0%}降至2026年的{current:.0%}")
        print(f"累计被挤占比例: {crowding_out:.1f}%")
        
        return {
            'crowding_out_rate': crowding_out,
            'ai_budget_2026': self.it_budget_allocation['2026E']['ai'],
            'traditional_software_2026': self.it_budget_allocation['2026E']['traditional_software']
        }
    
    def calculate_ibm_ai_exposure(self) -> float:
        """计算IBM对AI预算迁移的风险敞口"""
        # IBM的软件业务中，传统软件（非AI）占比
        traditional_software_revenue = 7.0  # 百亿
        ai_software_revenue = 1.2  # 假设IBM AI相关收入
        
        # 如果AI预算继续挤占传统软件，IBM面临的收入风险
        traditional_exposure = traditional_software_revenue * 0.15  # 假设15%的传统软件收入面临风险
        ai_offset = ai_software_revenue * 0.3  # AI增长可抵消部分
        
        net_risk = traditional_exposure - ai_offset
        print(f"\n=== IBM AI预算风险敞口估算 ===")
        print(f"传统软件收入风险敞口: ${traditional_exposure:.1f}B")
        print(f"AI收入增长抵消: ${ai_offset:.1f}B")
        print(f"净风险敞口: ${net_risk:.1f}B")
        
        return net_risk


# 执行分析
analyzer = IBMBudgetAnalysis()
df = analyzer.analyze_revenue_trend()
result = analyzer.simulate_budget_crowding_out()
risk = analyzer.calculate_ibm_ai_exposure()

// AI资本开支规模分析
package main

import (
    "fmt"
    "math"
)

type CloudCapEx struct {
    Company        string
    FiveYearCapEx  float64 // 万亿美元
    AnnualCapEx    float64 // 万亿美元/年
    MainFocus      string
    DataCenterMW   int     // 数据中心容量（MW）
}

func analyzeCapExScale() {
    fmt.Println("=== 五大云厂商AI资本开支（2026-2030） ===")
    
    companies := []CloudCapEx{
        {"Microsoft", 1.8, 0.36, "Copilot+Azure AI+Infra", 15000},
        {"Amazon", 1.5, 0.30, "AWS AI+Trainium+Bedrock", 12000},
        {"Meta", 1.0, 0.20, "Llama+AI Research+Infra", 8000},
        {"Google", 0.9, 0.18, "Gemini+TPU+DeepMind", 10000},
        {"Oracle", 0.6, 0.12, "OCI+GPU Cloud", 5000},
    }
    
    total := 0.0
    for _, c := range companies {
        fmt.Printf("%-15s $%.1fT ($%.2fT/yr) | %s | %dMW\n",
            c.Company, c.FiveYearCapEx, c.AnnualCapEx,
            c.MainFocus, c.DataCenterMW)
        total += c.FiveYearCapEx
    }
    
    fmt.Printf("\n总计: $%.1fT (5.8万亿美元)\n", total)
    fmt.Printf("年均: $%.2fT/年\n", total/5.0)
    
    // 对比分析
    fmt.Println("\n=== 规模对比 ===")
    type Comparison struct {
        Name   string
        Amount float64
        Unit   string
    }
    
    comparisons := []Comparison{
        {"IBM 2025全年营收", 0.063, "万亿美元"},
        {"全球软件市场规模(2025)", 0.75, "万亿美元"},
        {"全球半导体市场规模(2025)", 0.62, "万亿美元"},
        {"全球军费开支(2025)", 2.4, "万亿美元"},
        {"AI资本开支(5年)", 5.8, "万亿美元"},
        {"AI资本开支(年均)", 1.16, "万亿美元"},
    }
    
    fmt.Printf("%-35s %15s\n", "项目", "金额")
    fmt.Println("-" * 52)
    for _, comp := range comparisons {
        fmt.Printf("%-35s %13.2f %s\n", comp.Name, comp.Amount, comp.Unit)
    }
    
    // 相当于每年吃掉全球一半软件市场
    annualAI := total / 5.0
    globalSoftwareMarket := 0.75
    ratio := annualAI / globalSoftwareMarket * 100
    fmt.Printf("\n💡 AI资本开支/全球软件市场: %.0f%%\n", ratio)
    fmt.Printf("💡 相当于每年AI基建投入(%.2fT)接近全球软件市场(%.2fT)\n", annualAI, globalSoftwareMarket)
    fmt.Printf("💡 这就是IBM被"挤出"的直接原因：企业CIO把钱花在了AI服务器上，而不是软件license上\n")
}

func main() {
    analyzeCapExScale()
}

"""
软件行业估值重构模型
"""

import numpy as np
from typing import Dict, List

class SoftwareValuationModel:
    """软件行业估值重构分析"""
    
    def __init__(self):
        # 2019-2026年软件公司的估值倍数变化
        self.valuation_metrics = {
            '2019': {'EV/Revenue': 8.5, 'EV/EBITDA': 25.0, 'P/E': 35.0, 'Rule_of_40': 35},
            '2020': {'EV/Revenue': 12.0, 'EV/EBITDA': 30.0, 'P/E': 40.0, 'Rule_of_40': 38},
            '2021': {'EV/Revenue': 15.0, 'EV/EBITDA': 35.0, 'P/E': 50.0, 'Rule_of_40': 42},
            '2022': {'EV/Revenue': 6.0, 'EV/EBITDA': 18.0, 'P/E': 25.0, 'Rule_of_40': 30},
            '2023': {'EV/Revenue': 7.0, 'EV/EBITDA': 20.0, 'P/E': 28.0, 'Rule_of_40': 32},
            '2024': {'EV/Revenue': 8.0, 'EV/EBITDA': 22.0, 'P/E': 30.0, 'Rule_of_40': 33},
            '2025': {'EV/Revenue': 6.5, 'EV/EBITDA': 18.0, 'P/E': 25.0, 'Rule_of_40': 28},
            '2026E': {'EV/Revenue': 5.0, 'EV/EBITDA': 14.0, 'P/E': 20.0, 'Rule_of_40': 25},
        }
        
        # 受影响最大的软件细分领域
        self.impacted_segments = {
            'IT服务与咨询': {
                'exposure': 0.85,  # 85%收入来自传统企业IT
                'ai_substitution_risk': 0.6,  # 60%的工作可被AI替代
                'representative': 'IBM, Accenture, Infosys'
            },
            '传统ERP/CRM': {
                'exposure': 0.70,
                'ai_substitution_risk': 0.4,
                'representative': 'SAP, Oracle, Salesforce'
            },
            '系统管理软件': {
                'exposure': 0.75,
                'ai_substitution_risk': 0.5,
                'representative': 'ServiceNow, BMC, Broadcom'
            },
            '数据分析与BI': {
                'exposure': 0.60,
                'ai_substitution_risk': 0.55,
                'representative': 'Tableau, MicroStrategy, SAS'
            },
            'AI原生软件': {
                'exposure': 0.15,
                'ai_substitution_risk': 0.1,
                'representative': 'Cursor, Copilot, Cursor.sh'
            }
        }
    
    def analyze_valuation_trend(self) -> Dict:
        """分析估值倍数变化趋势"""
        print("=== 软件行业估值倍数演变（2019-2026E） ===")
        print(f"{'年份':<8} {'EV/Rev':<10} {'EV/EBITDA':<12} {'P/E':<10} {'Rule of 40':<12}")
        print("-" * 52)
        
        for year, metrics in self.valuation_metrics.items():
            print(f"{year:<8} {metrics['EV/Revenue']:<10.1f} "
                  f"{metrics['EV/EBITDA']:<12.1f} {metrics['P/E']:<10.1f} "
                  f"{metrics['Rule_of_40']:<12d}")
        
        # 计算估值压缩
        peak_ev = self.valuation_metrics['2021']['EV/Revenue']
        current_ev = self.valuation_metrics['2026E']['EV/Revenue']
        compression = (peak_ev - current_ev) / peak_ev * 100
        
        print(f"\nEV/Revenue 从峰值{peak_ev:.1f}x压缩至{current_ev:.1f}x")
        print(f"估值压缩幅度: {compression:.1f}%")
        
        return {'peak_ev_rev': peak_ev, 'current_ev_rev': current_ev, 'compression': compression}
    
    def analyze_segment_impact(self) -> List[Dict]:
        """分析各细分领域受影响程度"""
        print("\n=== 软件细分领域AI冲击分析 ===")
        print(f"{'领域':<20} {'传统IT敞口':<12} {'AI替代风险':<12} {'综合风险':<10}")
        print("-" * 54)
        
        results = []
        for segment, data in self.impacted_segments.items():
            combined_risk = data['exposure'] * data['ai_substitution_risk']
            risk_level = '🔴高' if combined_risk > 0.4 else '🟡中' if combined_risk > 0.2 else '🟢低'
            results.append({
                'segment': segment,
                'exposure': data['exposure'],
                'ai_risk': data['ai_substitution_risk'],
                'combined_risk': combined_risk,
                'risk_level': risk_level
            })
            print(f"{segment:<20} {data['exposure']:<12.0%} "
                  f"{data['ai_substitution_risk']:<12.0%} "
                  f"{risk_level:<10}")
        
        return results
    
    def simulate_market_cap_impact(self, ibm_market_cap_before: float = 1520) -> Dict:
        """模拟行业市值影响（十亿美元）"""
        print("\n=== 行业市值影响模拟 ===")
        
        # 假设IBM暴跌25%的示范效应
        contagion_factors = {
            'IT服务': 0.15,      # 15%的市值可能蒸发
            '传统软件': 0.10,     # 10%
            'AI原生': 0.02,      # 2%
            '云基础设施': 0.05,   # 5%
        }
        
        market_caps = {
            'IT服务': 1200,       # 十亿美元
            '传统软件': 2500,
            'AI原生': 800,
            '云基础设施': 3500,
        }
        
        total_impact = 0
        for sector, factor in contagion_factors.items():
            impact = market_caps[sector] * factor
            total_impact += impact
            print(f"{sector:<12} 市值${market_caps[sector]:,}B × {factor:.0%} = -${impact:.0f}B")
        
        print(f"\n总计潜在市值蒸发: ${total_impact:.0f}B")
        print(f"IBM示范效应为主要催化剂")
        
        return {'total_impact': total_impact}
    
    def predict_next_6_months(self) -> str:
        """预测未来6个月"""
        print("\n=== 未来6个月预测 ===")
        
        predictions = [
            "Q2 2026财报季将验证IBM是否个案，预计更多传统软件公司业绩预警",
            "AI硬件厂商（戴尔、惠普、美光、超微）短期受益于预算转移",
            "软件公司加速推出AI原生产品以对冲传统业务下滑",
            "企业CIO面临'AI or die'决策：不投资AI=被淘汰，但投资AI=压缩传统软件预算",
            "SaaS续约率下降进入加速期，AI原生工具替代传统软件的速度超预期",
            "软件行业并购加速：传统软件厂商收购AI初创公司补足能力",
        ]
        
        for i, p in enumerate(predictions, 1):
            print(f"{i}. {p}")
        
        return "传统软件行业面临结构性估值重构，AI资本开支的'挤出效应'将持续至少12-18个月"


# 执行分析
model = SoftwareValuationModel()
valuation = model.analyze_valuation_trend()
segments = model.analyze_segment_impact()
impact = model.simulate_market_cap_impact()
outlook = model.predict_next_6_months()

// IT预算分配趋势分析
package main

import (
    "fmt"
    "math"
)

type BudgetAllocation struct {
    Year                int
    TraditionalSoftware float64
    Cloud               float64
    AI                  float64
    Infrastructure      float64
}

func analyzeBudgetTrend() {
    data := []BudgetAllocation{
        {2022, 0.45, 0.30, 0.10, 0.15},
        {2023, 0.40, 0.32, 0.15, 0.13},
        {2024, 0.35, 0.33, 0.20, 0.12},
        {2025, 0.28, 0.32, 0.30, 0.10},
        {2026, 0.22, 0.30, 0.40, 0.08},
    }

    fmt.Println("=== Enterprise IT Budget Allocation Trends ===")
    fmt.Printf("%-6s %-20s %-10s %-10s %-15s\n", "Year", "Traditional SW", "Cloud", "AI", "Infrastructure")
    fmt.Println("--------------------------------------------------------------------------------")
    
    for _, d := range data {
        fmt.Printf("%-6d %-20.0f%% %-10.0f%% %-10.0f%% %-15.0f%%\n",
            d.Year, d.TraditionalSoftware*100, d.Cloud*100, d.AI*100, d.Infrastructure*100)
    }
    
    // 计算年化变化率
    first := data[0]
    last := data[len(data)-1]
    
    traditionalDecline := (first.TraditionalSoftware - last.TraditionalSoftware) / float64(len(data)-1) * 100
    aiGrowth := (last.AI - first.AI) / float64(len(data)-1) * 100
    
    fmt.Printf("\n传统软件年均下降: %.1f%%\n", traditionalDecline)
    fmt.Printf("AI预算年均增长: %.1f%%\n", aiGrowth)
    fmt.Printf("2026年AI预算已是传统软件的%.1f倍\n", last.AI/last.TraditionalSoftware)
}

func main() {
    analyzeBudgetTrend()
    
    // 模拟IBM暴跌的连锁反应
    fmt.Println("\n=== IBM暴跌连锁反应模拟 ===")
    
    type Contagion struct {
        Sector    string
        Impact    float64
        Reason    string
    }
    
    reactions := []Contagion{
        {"IT Services Peers", 0.12, "Similar exposure to AI substitution"},
        {"Legacy Software", 0.08, "Budget reallocation pressure"},
        {"AI Hardware Makers", -0.05, "Capital inflow beneficiary"},
        {"Cloud Hyperscalers", 0.02, "Long-term AI demand tailwind"},
        {"Enterprise SaaS", 0.10, "Subscription renewal risk"},
    }
    
    fmt.Printf("%-25s %-10s %s\n", "Sector", "Impact", "Reason")
    fmt.Println("----------------------------------------------------------------")
    for _, r := range reactions {
        impactStr := fmt.Sprintf("%+.1f%%", r.Impact*100)
        if r.Impact < 0 {
            impactStr = fmt.Sprintf("%+.1f%% (benefit)", r.Impact*100)
        }
        fmt.Printf("%-25s %-12s %s\n", r.Sector, impactStr, r.Reason)
    }
    
    // 高盛5.8万亿的数学
    totalCapEx := 5.8 // 万亿美元
    years := 5
    annualCapEx := totalCapEx / float64(years)
    globalSoftwareMarket := 0.75 // 万亿美元
    
    fmt.Printf("\n=== 高盛5.8万亿的含义 ===\n")
    fmt.Printf("年均AI资本开支: $%.2f万亿\n", annualCapEx)
    fmt.Printf("全球软件市场规模: $%.2f万亿\n", globalSoftwareMarket)
    fmt.Printf("AI基建/软件市场比: %.0f%%\n", annualCapEx/globalSoftwareMarket*100)
    fmt.Printf("5年AI基建可买下: %.1f个全球软件市场\n", totalCapEx/globalSoftwareMarket)
}

"""
AI资本开支与软件市场交叉分析
"""

import numpy as np
import pandas as pd

def cross_analysis():
    """AI资本开支与软件市场交叉分析"""
    
    # 数据定义
    years = list(range(2022, 2027))
    ai_capex = [0.3, 0.5, 0.8, 1.1, 1.5]  # 万亿美元/年
    software_market = [0.65, 0.68, 0.72, 0.75, 0.78]  # 万亿美元
    ibm_revenue = [60.5, 61.9, 62.7, 63.0, 61.0]  # 十亿美元
    ibm_market_cap = [1280, 1350, 1420, 1520, 1140]  # 十亿美元
    
    # 计算AI资本开支占比
    ai_ratio = [a / s for a, s in zip(ai_capex, software_market)]
    
    df = pd.DataFrame({
        'AI_CapEx(T)': ai_capex,
        'Software_Market(T)': software_market,
        'AI_vs_Software_Ratio': ai_ratio,
        'IBM_Revenue(B)': ibm_revenue,
        'IBM_MarketCap(B)': ibm_market_cap
    }, index=years)
    
    print("=== 交叉分析数据 ===")
    print(df.to_string())
    
    # 相关性分析
    correlation = np.corrcoef(ai_ratio, ibm_market_cap)[0, 1]
    print(f"\nAI开支占比与IBM市值相关性: {correlation:.3f}")
    print("(负相关越强，说明AI资本开支挤占对IBM的影响越大)")
    
    # 趋势外推
    from scipy import stats
    
    slope, intercept, r_value, p_value, std_err = stats.linregress(
        range(len(ai_ratio)), ai_ratio
    )
    
    print(f"\nAI占比趋势: y = {slope:.4f}x + {intercept:.4f}")
    print(f"R² = {r_value**2:.4f}")
    
    # 预测2027年
    pred_2027 = slope * 5 + intercept
    print(f"预测2027年AI/SW占比: {pred_2027:.1%}")
    print(f"如果软件市场保持7%增长: 2027年软件市场≈$0.83T")
    print(f"AI资本开支/软件市场比例将超过{pred_2027:.0%}")
    
    return df

df = cross_analysis()