wOBA = (0.69 * BB + 0.72 * HBP + 0.89 * 1B + 1.27 * 2B + 1.62 * 3B + 2.10 * HR)
       / (AB + BB - IBB + SF + HBP)

FIP = ((13 * HR) + (3 * (BB + HBP)) - (2 * K)) / IP + FIP定数

# インストール: pip install pybaseball

import pybaseball as pb
import pandas as pd
import matplotlib.pyplot as plt

pb.cache.enable()

# 大谷翔平のStatcastデータ（2023年シーズン）
ohtani_id = 660271
data = pb.statcast_pitcher(
    start_dt='2023-04-01',
    end_dt='2023-10-01',
    player_id=ohtani_id
)

print(f"総投球数: {len(data)}")
print(data[['pitch_type', 'release_speed', 'release_spin_rate',
            'pfx_x', 'pfx_z']].describe())

# 球種別速度・回転数の可視化
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

pitch_speed = data.groupby('pitch_type')['release_speed'].mean().sort_values(ascending=False)
axes[0].bar(pitch_speed.index, pitch_speed.values, color='steelblue')
axes[0].set_title("大谷翔平 球種別平均球速 (mph)")
axes[0].set_xlabel("球種")
axes[0].set_ylabel("球速 (mph)")

pitch_spin = data.groupby('pitch_type')['release_spin_rate'].mean().sort_values(ascending=False)
axes[1].bar(pitch_spin.index, pitch_spin.values, color='coral')
axes[1].set_title("大谷翔平 球種別平均回転数 (RPM)")
axes[1].set_xlabel("球種")
axes[1].set_ylabel("回転数 (RPM)")

plt.tight_layout()
plt.savefig('ohtani_pitch_analysis.png', dpi=150)
plt.show()

コーナー3ポイント（成功率38%）の期待値：0.38 × 3 = 1.14点
ミドルレンジ2ポイント（成功率45%）の期待値：0.45 × 2 = 0.90点

# インストール: pip install nba_api

from nba_api.stats.endpoints import playercareerstats, leaguedashplayerstats
from nba_api.stats.static import players
import pandas as pd
import matplotlib.pyplot as plt
import time

def get_player_id(name):
    all_players = players.get_players()
    for p in all_players:
        if p['full_name'].lower() == name.lower():
            return p['id']
    return None

# レブロン・ジェームズのキャリアスタット
lebron_id = get_player_id('LeBron James')
time.sleep(1)

career = playercareerstats.PlayerCareerStats(player_id=lebron_id)
career_df = career.get_data_frames()[0]

career_df['PTS_PER_GAME'] = career_df['PTS'] / career_df['GP']
career_df['AST_PER_GAME'] = career_df['AST'] / career_df['GP']
career_df['REB_PER_GAME'] = career_df['REB'] / career_df['GP']

fig, axes = plt.subplots(1, 3, figsize=(18, 6))
metrics = [
    ('PTS_PER_GAME', 'Points', 'royalblue'),
    ('AST_PER_GAME', 'Assists', 'forestgreen'),
    ('REB_PER_GAME', 'Rebounds', 'crimson')
]

for ax, (col, label, color) in zip(axes, metrics):
    ax.plot(career_df['SEASON_ID'], career_df[col],
            marker='o', color=color, linewidth=2)
    ax.set_title(f'LeBron James — {label}/Game by Season')
    ax.set_xlabel('Season')
    ax.set_ylabel(f'{label}/Game')
    ax.tick_params(axis='x', rotation=45)
    ax.grid(alpha=0.3)

plt.suptitle("LeBron James Career Stats Trajectory", fontsize=14, fontweight='bold')
plt.tight_layout()
plt.show()

PPDA = 相手チームのパス数 / (タックル + インターセプト + ファウル + チャレンジ成功)

# インストール: pip install statsbombpy mplsoccer

from statsbombpy import sb
from mplsoccer import Pitch, VerticalPitch
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

# StatsBombオープンデータ
competitions = sb.competitions()
print(competitions[['competition_id', 'competition_name', 'season_name']].head(20))

# 2018 FIFAワールドカップ
matches = sb.matches(competition_id=43, season_id=3)

final_id = matches[
    (matches['home_team'] == 'France') &
    (matches['away_team'] == 'Croatia')
]['match_id'].values[0]

events = sb.events(match_id=final_id)
shots = events[events['type'] == 'Shot'].copy()

# ショットマップの可視化
pitch = VerticalPitch(
    pitch_type='statsbomb',
    pitch_color='grass',
    line_color='white',
    half=True
)

fig, ax = pitch.draw(figsize=(8, 12))

for team_color, team in [('#1f77b4', 'France'), ('#d62728', 'Croatia')]:
    team_shots = shots[shots['team'] == team]
    for _, shot in team_shots.iterrows():
        x = shot['location'][0]
        y = shot['location'][1]
        try:
            xg = shot['shot']['statsbomb_xg']
            outcome = shot['shot']['outcome']['name']
            marker = '*' if outcome == 'Goal' else 'o'
            ax.scatter(y, x, s=xg * 1000, c=team_color,
                      marker=marker, alpha=0.7,
                      edgecolors='white', linewidths=0.5)
        except (KeyError, TypeError):
            pass

ax.set_title('2018 FIFAワールドカップ決勝\nフランス vs クロアチア ショットマップ\n(サイズ=xG、星=ゴール)',
             fontsize=11, pad=20)
plt.tight_layout()
plt.savefig('shot_map_final.png', dpi=150, bbox_inches='tight')
plt.show()

import pandas as pd
import numpy as np
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, roc_auc_score

np.random.seed(42)
n_players = 500

data = pd.DataFrame({
    'acute_load': np.random.normal(450, 80, n_players),
    'chronic_load': np.random.normal(400, 60, n_players),
    'sleep_quality': np.random.uniform(3, 10, n_players),
    'hrv': np.random.normal(65, 15, n_players),
    'sprint_distance': np.random.normal(350, 50, n_players),
    'days_since_rest': np.random.randint(0, 7, n_players),
    'age': np.random.randint(18, 38, n_players),
    'previous_injuries': np.random.randint(0, 5, n_players)
})

data['acwr'] = data['acute_load'] / data['chronic_load']

injury_prob = (
    0.1 +
    0.3 * (data['acwr'] > 1.5).astype(float) +
    0.15 * (data['sleep_quality'] < 5).astype(float) +
    0.1 * (data['hrv'] < 50).astype(float) +
    0.05 * (data['previous_injuries'] > 2).astype(float)
)
data['injured'] = (np.random.random(n_players) < injury_prob).astype(int)

features = ['acwr', 'sleep_quality', 'hrv', 'sprint_distance',
            'days_since_rest', 'age', 'previous_injuries']
X = data[features]
y = data['injured']

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

model = GradientBoostingClassifier(n_estimators=200, max_depth=4,
                                   learning_rate=0.05, random_state=42)
model.fit(X_train_s, y_train)

y_pred = model.predict(X_test_s)
y_prob = model.predict_proba(X_test_s)[:, 1]

print(classification_report(y_test, y_pred))
print(f"ROC-AUC: {roc_auc_score(y_test, y_prob):.4f}")

import numpy as np
from scipy.stats import poisson

def predict_match(home_attack, home_defense, away_attack, away_defense,
                  home_advantage=1.1):
    """
    ポアソン分布を利用した試合結果予測
    attack/defenseインデックス：リーグ平均 = 1.0
    """
    league_avg_goals = 1.35

    home_exp = home_attack * away_defense * league_avg_goals * home_advantage
    away_exp = away_attack * home_defense * league_avg_goals

    max_goals = 10
    home_win = draw = away_win = 0

    for i in range(max_goals):
        for j in range(max_goals):
            p = poisson.pmf(i, home_exp) * poisson.pmf(j, away_exp)
            if i > j:
                home_win += p
            elif i == j:
                draw += p
            else:
                away_win += p

    return {
        'home_goals_expected': round(home_exp, 2),
        'away_goals_expected': round(away_exp, 2),
        'home_win_prob': round(home_win, 3),
        'draw_prob': round(draw, 3),
        'away_win_prob': round(away_win, 3)
    }

# マンチェスター・シティ vs アーセナル
result = predict_match(
    home_attack=1.4, home_defense=0.7,
    away_attack=1.3, away_defense=0.75
)
print("マンチェスター・シティ vs アーセナル:")
for k, v in result.items():
    print(f"  {k}: {v}")

import pandas as pd
import numpy as np

np.random.seed(42)
n_players = 100

players_data = pd.DataFrame({
    'player_name': [f'Player_{i:03d}' for i in range(n_players)],
    'team': np.random.choice(['LAL', 'GSW', 'BOS', 'MIA', 'DEN'], n_players),
    'position': np.random.choice(['PG', 'SG', 'SF', 'PF', 'C'], n_players),
    'age': np.random.randint(19, 38, n_players),
    'games_played': np.random.randint(30, 82, n_players),
    'minutes': np.random.normal(28, 8, n_players).clip(8, 40),
    'points': np.random.normal(14, 6, n_players).clip(0, 40),
    'rebounds': np.random.normal(5, 2.5, n_players).clip(0, 15),
    'assists': np.random.normal(4, 2.5, n_players).clip(0, 12),
    'fg_pct': np.random.normal(0.46, 0.06, n_players).clip(0.2, 0.7),
    'turnovers': np.random.normal(2.5, 1, n_players).clip(0, 6),
    'steals': np.random.normal(1.2, 0.5, n_players).clip(0, 3.5),
    'blocks': np.random.normal(0.8, 0.6, n_players).clip(0, 4),
    'salary_million': np.random.lognormal(2.5, 0.7, n_players)
})

# 簡易PER計算
players_data['per_approx'] = (
    players_data['points'] +
    players_data['rebounds'] * 1.2 +
    players_data['assists'] * 1.5 +
    players_data['steals'] * 2 +
    players_data['blocks'] * 2 -
    players_data['turnovers'] * 1.5
) / players_data['minutes'] * 15

players_data['value_score'] = players_data['per_approx'] / players_data['salary_million']

print("ポジション別平均スタット:")
pos_stats = players_data.groupby('position')[
    ['points', 'rebounds', 'assists', 'per_approx']
].mean().round(2)
print(pos_stats)

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import cross_val_score
import matplotlib.pyplot as plt

features = ['age', 'minutes', 'fg_pct', 'rebounds', 'assists',
            'turnovers', 'steals', 'blocks']
target = 'points'

X = players_data[features]
y = players_data[target]

model = RandomForestRegressor(n_estimators=100, random_state=42)
cv_scores = cross_val_score(model, X, y, cv=5, scoring='r2')
print(f"5分割交差検証 R²: {cv_scores.mean():.4f} (±{cv_scores.std():.4f})")

model.fit(X, y)

importance_df = pd.DataFrame({
    'feature': features,
    'importance': model.feature_importances_
}).sort_values('importance', ascending=False)

fig, ax = plt.subplots(figsize=(10, 6))
ax.barh(importance_df['feature'], importance_df['importance'], color='steelblue')
ax.set_title('NBA得点予測モデル — 特徴量重要度')
ax.set_xlabel('重要度')
plt.tight_layout()
plt.show()